☰

WME FC Layer

Adds a Functional Class layer for states that publish ArcGIS FC data.

目前为 2021-06-03 提交的版本。查看 最新版本。

  1. /* global W */
  2. /* global OpenLayers */
  3. /* global I18n */
  4. /* global unsafeWindow */
  5. /* global GM_info */
  6. /* global WazeWrap */
  7.  
  8. // // ==UserScript==
  9. // @name         WME FC Layer
  10. // @namespace    https://greasyfork.org/users/45389
  11. // @version      2021.02.19.001
  12. // @description  Adds a Functional Class layer for states that publish ArcGIS FC data.
  13. // @author       MapOMatic
  14. // @include      /^https:\/\/(www|beta)\.waze\.com\/(?!user\/)(.{2,6}\/)?editor\/?.*$/
  15. // @license      GNU GPLv3
  16. // @contributionURL https://github.com/WazeDev/Thank-The-Authors
  17. // @require      https://greasyfork.org/scripts/39002-bluebird/code/Bluebird.js?version=255146
  18. // @require      https://greasyfork.org/scripts/24851-wazewrap/code/WazeWrap.js
  19. // @grant        GM_xmlhttpRequest
  20. // @connect      arcgis.com
  21. // @connect      arkansas.gov
  22. // @connect      azdot.gov
  23. // @connect      coloradodot.info
  24. // @connect      delaware.gov
  25. // @connect      dc.gov
  26. // @connect      ga.gov
  27. // @connect      uga.edu
  28. // @connect      hawaii.gov
  29. // @connect      idaho.gov
  30. // @connect      in.gov
  31. // @connect      iowadot.gov
  32. // @connect      illinois.gov
  33. // @connect      ksdot.org
  34. // @connect      ky.gov
  35. // @connect      la.gov
  36. // @connect      maine.gov
  37. // @connect      md.gov
  38. // @connect      ma.us
  39. // @connect      state.mi.us
  40. // @connect      modot.org
  41. // @connect      mt.gov
  42. // @connect      unh.edu
  43. // @connect      ny.gov
  44. // @connect      ncdot.gov
  45. // @connect      nd.gov
  46. // @connect      oh.us
  47. // @connect      or.us
  48. // @connect      penndot.gov
  49. // @connect      sd.gov
  50. // @connect      shelbycountytn.gov
  51. // @connect      utah.gov
  52. // @connect      vermont.gov
  53. // @connect      wa.gov
  54. // @connect      wv.gov
  55. // @connect      wyoroad.info
  56. // ==/UserScript==
  57.  
  58. /* eslint-disable */
  59.  
  60. (function () {
  61.     'use strict';
  62.  
  63.     var _settingsStoreName = 'wme_fc_layer';
  64.     var _alertUpdate = false;
  65.     var _debugLevel = 2;
  66.     var _scriptVersion = GM_info.script.version;
  67.     var _scriptVersionChanges = [
  68.         GM_info.script.name,
  69.         'v' + _scriptVersion,
  70.         '',
  71.         'What\'s New',
  72.         '------------------------------',
  73.         ''  // Add important stuff here when _alertUpdate = true.
  74.     ].join('\n');
  75.     var _mapLayer = null;
  76.     var _isAM = false;
  77.     var _uid;
  78.     var _settings = {};
  79.     var _r;
  80.     var _mapLayerZIndex = 334;
  81.     var _betaIDs = [103400892];
  82.     var _statesHash = {
  83.         'Alabama': 'AL', 'Alaska': 'AK', 'American Samoa': 'AS', 'Arizona': 'AZ', 'Arkansas': 'AR', 'California': 'CA', 'Colorado': 'CO', 'Connecticut': 'CT', 'Delaware': 'DE', 'District of Columbia': 'DC',
  84.         'Federated States Of Micronesia': 'FM', 'Florida': 'FL', 'Georgia': 'GA', 'Guam': 'GU', 'Hawaii': 'HI', 'Idaho': 'ID', 'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA', 'Kansas': 'KS',
  85.         'Kentucky': 'KY', 'Louisiana': 'LA', 'Maine': 'ME', 'Marshall Islands': 'MH', 'Maryland': 'MD', 'Massachusetts': 'MA', 'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS', 'Missouri': 'MO',
  86.         'Montana': 'MT', 'Nebraska': 'NE', 'Nevada': 'NV', 'New Hampshire': 'NH', 'New Jersey': 'NJ', 'New Mexico': 'NM', 'New York': 'NY', 'North Carolina': 'NC', 'North Dakota': 'ND',
  87.         'Northern Mariana Islands': 'MP', 'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR', 'Palau': 'PW', 'Pennsylvania': 'PA', 'Puerto Rico': 'PR', 'Rhode Island': 'RI', 'South Carolina': 'SC',
  88.         'South Dakota': 'SD', 'Tennessee': 'TN', 'Texas': 'TX', 'Utah': 'UT', 'Vermont': 'VT', 'Virgin Islands': 'VI', 'Virginia': 'VA', 'Washington': 'WA', 'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY'
  89.     };
  90.  
  91.     function reverseStatesHash(stateAbbr) {
  92.         for (var stateName in _statesHash) {
  93.             if (_statesHash[stateName] === stateAbbr) return stateName;
  94.         }
  95.     }
  96.     var _stateSettings = {
  97.         global: {
  98.             roadTypes: ['St', 'PS', 'PS2', 'mH', 'MH', 'Ew', 'Rmp', 'Fw'], // Ew = Expressway.  For FC's that make it uncertain if they should be MH or FW.
  99.             getFeatureRoadType: function (feature, layer) {
  100.                 var fc = feature.attributes[layer.fcPropName];
  101.                 return this.getRoadTypeFromFC(fc, layer);
  102.             },
  103.             getRoadTypeFromFC: function (fc, layer) {
  104.                 for (var roadType in layer.roadTypeMap) {
  105.                     if (layer.roadTypeMap[roadType].indexOf(fc) !== -1) {
  106.                         return roadType;
  107.                     }
  108.                 }
  109.                 return null;
  110.             },
  111.             isPermitted: function (stateAbbr) { if (_betaIDs.indexOf(_uid) !== -1) return true; var state = _stateSettings[stateAbbr]; if (state.isPermitted) { return state.isPermitted(); } else { return (_r >= 3 && _isAM) || (_r >= 4); } },
  112.             getMapLayer: function (stateAbbr, layerID) {
  113.                 var returnValue;
  114.                 _stateSettings[stateAbbr].fcMapLayers.forEach(function (layer) {
  115.                     if (layer.layerID === layerID) {
  116.                         returnValue = layer;
  117.                     }
  118.                 });
  119.                 return returnValue;
  120.             }
  121.         },
  122.         AL: {
  123.             baseUrl: 'https://services.arcgis.com/LZzQi3xDiclG6XvQ/arcgis/rest/services/HPMS_Year2017_F_System_Data/FeatureServer/',
  124.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  125.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  126.             fcMapLayers: [
  127.                 {
  128.                     layerID: 0, fcPropName: 'F_SYSTEM_V', idPropName: 'OBJECTID', outFields: ['FID', 'F_SYSTEM_V', 'State_Sys'],
  129.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  130.                 }
  131.             ],
  132.             isPermitted: function () { return _r >= 3; },
  133.             information: { Source: 'ALDOT', Permission: 'Visible to R3+', Description: 'Federal and State highways set to a minimum of mH.' },
  134.             getWhereClause: function (context) {
  135.                 if (context.mapContext.zoom < 4) {
  136.                     return context.layer.fcPropName + "<>7";
  137.                 } else {
  138.                     return null;
  139.                 }
  140.             },
  141.             getFeatureRoadType: function (feature, layer) {
  142.                 var fc = parseInt(feature.attributes[layer.fcPropName]);
  143.                 if (fc > 4 && feature.attributes.State_Sys === 'YES') { fc = 4; }
  144.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  145.             }
  146.         },
  147.         AK: {
  148.             baseUrl: 'https://services.arcgis.com/r4A0V7UzH9fcLVvv/ArcGIS/rest/services/AKDOTPF_Route_Data/FeatureServer/',
  149.             defaultColors: { Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  150.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  151.             fcMapLayers: [
  152.                 {
  153.                     layerID: 13, fcPropName: 'Functional_Class', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'Functional_Class'],
  154.                     roadTypeMap: { Ew: [1, 2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  155.                 }
  156.             ],
  157.             information: { Source: 'Alaska DOT&PF', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  158.             getWhereClause: function (context) {
  159.                 if (context.mapContext.zoom < 4) {
  160.                     return context.layer.fcPropName + "<>7";
  161.                 } else {
  162.                     return null;
  163.                 }
  164.             },
  165.             getFeatureRoadType: function (feature, layer) {
  166.                 if (layer.getFeatureRoadType) {
  167.                     return layer.getFeatureRoadType(feature);
  168.                 } else {
  169.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  170.                 }
  171.             }
  172.         },
  173.         AZ: {
  174.             baseUrl: 'https://services6.arcgis.com/jTQSeSIplkoqFMZe/ArcGIS/rest/services/FunctionalClass/FeatureServer/',
  175.             defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  176.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  177.             fcMapLayers: [
  178.                 {
  179.                     layerID: 1, fcPropName: 'FuncCode', idPropName: 'OBJECTID',
  180.                     outFields: ['OBJECTID', 'FuncCode', 'OnRoad'],
  181.                     roadTypeMap: { Fw: [1, 11], Ew: [2, 3, 12], MH: [4, 14], mH: [6, 16], PS: [7, 17, 8, 18], St: [] }, maxRecordCount: 1000, supportsPagination: false
  182.                 }
  183.             ],
  184.             information: { Source: 'ADOT', Permission: 'Visible to R4+ or R3-AM' },
  185.             getWhereClause: function (context) {
  186.                 return context.layer.fcPropName + ' NOT IN (9, 19)';
  187.             },
  188.             // getFeatureRoadType: function (feature, layer) {
  189.             //     if (layer.getFeatureRoadType) {
  190.             //         return layer.getFeatureRoadType(feature);
  191.             //     } else {
  192.             //         return _stateSettings.global.getFeatureRoadType(feature, layer);
  193.             //     }
  194.             // }
  195.             getFeatureRoadType: function (feature, layer) {
  196.                 var roadID = feature.attributes.OnRoad.trim().replace(/  +/g, ' ');
  197.                 var roadNum = parseInt(roadID.substring(2, 5));
  198.                 var fc = parseInt(feature.attributes[layer.fcPropName]);
  199.                 fc = (fc === 2) ? 4 : fc % 10;
  200.                 var azIH = [8, 10, 11, 17, 19, 40]; // Interstate hwys in AZ
  201.                 var isUS = RegExp(/^U\D\d{3}\b/).test(roadID);
  202.                 var isState = RegExp(/^S\D\d{3}\b/).test(roadID);
  203.                 var isBiz = RegExp(/^SB\d{3}\b/).test(roadID);
  204.                 if (fc > 4 && isState && azIH.includes(roadNum) && isBiz) {
  205.                     fc = 4;
  206.                 } else if (fc > 4 && isUS) {
  207.                     fc = isBiz ? 6 : 4;
  208.                 } else if (fc > 6 && isState) {
  209.                     fc = isBiz ? 7 : 6;
  210.                 }
  211.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  212.             }
  213.         },
  214.         AR: {
  215.             baseUrl: 'https://gis.arkansas.gov/arcgis/rest/services/FEATURESERVICES/Transportation/FeatureServer/',
  216.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  217.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  218.             fcMapLayers: [
  219.                 {
  220.                     layerID: 8, fcPropName: 'functionalclass', idPropName: 'objectid', outFields: ['objectid', 'functionalclass', 'ah_route', 'ah_section'],
  221.                     roadTypeMap: { Fw: [1, 2], Ew: [], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  222.                 }
  223.             ],
  224.             information: { Source: 'ARDOT', Permission: 'Visible to R4+ or R3-AM' },
  225.             getWhereClause: function (context) {
  226.                 return null;
  227.             },
  228.             getFeatureRoadType: function (feature, layer) {
  229.                 var attr = feature.attributes;
  230.                 var fc = parseInt(attr[layer.fcPropName]);
  231.                 var roadID = parseInt(attr.ah_route);
  232.                 var usHwys = [49, 59, 61, 62, 63, 64, 65, 67, 70, 71, 79, 82, 165, 167, 270, 271, 278, 371, 412, 425];
  233.                 var isUS = usHwys.includes(roadID);
  234.                 var isState = roadID < 613;
  235.                 var isBiz = attr.ah_section[attr.ah_section.length - 1] === 'B';
  236.                 if (fc > 3 && isUS) {
  237.                     fc = isBiz ? 4 : 3;
  238.                 } else if (fc > 4 && isState) {
  239.                     fc = isBiz ? 5 : 4;
  240.                 }
  241.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  242.             }
  243.         },
  244.         CO: {
  245.             baseUrl: 'https://dtdapps.coloradodot.info/arcgis/rest/services/CPLAN/open_data_sde/FeatureServer/',
  246.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  247.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  248.             fcMapLayers: [
  249.                 {
  250.                     layerID: 14, fcPropName: 'FUNCCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCCLASS', 'ROUTE', 'REFPT'],
  251.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  252.                 },
  253.                 {
  254.                     layerID: 17, fcPropName: 'FUNCCLASSID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCCLASSID', 'ROUTE', 'FIPSCOUNTY'],
  255.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  256.                 },
  257.                 {
  258.                     layerID: 21, fcPropName: 'FUNCCLASSID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCCLASSID', 'ROUTE'],
  259.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  260.                 }
  261.             ],
  262.             isPermitted: function () { return _r >= 3; },
  263.             information: {
  264.                 Source: 'CDOT', Permission: 'Visible to R3+',
  265.                 Description: 'Please consult with a state manager before making any changes to road types based on the data presented.'
  266.             },
  267.             getWhereClause: function (context) {
  268.                 if (context.mapContext.zoom < 4) {
  269.                     return context.layer.fcPropName + "<>'7'";
  270.                 } else {
  271.                     return null;
  272.                 }
  273.             },
  274.             getFeatureRoadType: function (feature, layer) {
  275.                 var attr = feature.attributes;
  276.                 var fc = parseInt(attr[layer.fcPropName]);
  277.                 var route = attr.ROUTE.replace(/  +/g, ' ');
  278.                 if (layer.layerID === 7) {
  279.                     var rtnum = parseInt(route.slice(0, 3));
  280.                     var refpt = attr.REFPT;
  281.                     var hwys = [6, 24, 25, 34, 36, 40, 50, 70, 84, 85, 87, 138, 160, 285, 287, 350, 385, 400, 491, 550];
  282.                     var IH = [25, 70];
  283.                     // Exceptions first, then normal classification
  284.                     var doNothing = ['024D', '040G'];
  285.                     var notNothing = ['070K', '070L', '070O', '070Q', '070R'];
  286.                     var doMin = ['024E', '050D', '070O', '085F', '160D'];
  287.                     if (doNothing.includes(route) || (rtnum === 70 && route !== '070K' && !notNothing.includes(route))) { }
  288.                     else if (doMin.includes(route) ||
  289.                         (rtnum === 40 && refpt > 320 && refpt < 385) ||
  290.                         (rtnum === 36 && refpt > 79 && refpt < 100.99) ||
  291.                         (route === '034D' && refpt > 11)) {
  292.                         fc = 4;
  293.                     } else if (hwys.includes(rtnum)) {
  294.                         fc = Math.min(fc, 3);
  295.                     }
  296.                     else {
  297.                         fc = Math.min(fc, 4);
  298.                     }
  299.                 }
  300.                 else {
  301.                     // All exceptions
  302.                     var fips = parseInt(attr.FIPSCOUNTY);
  303.                     if ((fips === 19 && route === 'COLORADO BD') ||
  304.                         (fips === 37 && (route === 'GRAND AV' || route === 'S H6'))) { fc = 3; }
  305.                     else if (fips === 67 && route === 'BAYFIELDPAY') { fc = 4; }
  306.                 }
  307.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  308.             }
  309.         },
  310.         DE: {
  311.             baseUrl: 'https://firstmap.delaware.gov/arcgis/rest/services/Transportation/DE_FUNCTIONAL_CLASSIFICATION/MapServer/',
  312.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  313.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  314.             fcMapLayers: [
  315.                 {
  316.                     layerID: 0, fcPropName: 'VALUE_TEXT', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'VALUE_TEXT'], maxRecordCount: 1000, supportsPagination: false,
  317.                     roadTypeMap: { Fw: ['Interstate'], Ew: ['Other Expressways & Freeway'], MH: ['Other Principal Arterials'], mH: ['Minor Arterial'], PS: ['Major Collector', 'Minor Collector'], St: ['Local'] }
  318.                 }
  319.             ],
  320.             information: { Source: 'Delaware FirstMap', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  321.             getWhereClause: function (context) {
  322.                 if (context.mapContext.zoom < 4) {
  323.                     return context.layer.fcPropName + " <> 'Local'";
  324.                 } else {
  325.                     return null;
  326.                 }
  327.             },
  328.             getFeatureRoadType: function (feature, layer) {
  329.                 if (layer.getFeatureRoadType) {
  330.                     return layer.getFeatureRoadType(feature);
  331.                 } else {
  332.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  333.                 }
  334.             }
  335.         },
  336.         DC: {
  337.             baseUrl: 'https://maps2.dcgis.dc.gov/dcgis/rest/services/DCGIS_DATA/Transportation_WebMercator/MapServer/',
  338.             supportsPagination: false,
  339.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  340.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  341.             fetchAllFC: false,
  342.             fcMapLayers: [
  343.                 {
  344.                     layerID: 48, fcPropName: 'FUNCTIONALCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONALCLASS'], maxRecordCount: 1000, supportsPagination: false,
  345.                     roadTypeMap: { Fw: ['Interstate'], Ew: ['Other Freeway and Expressway'], MH: ['Principal Arterial'], mH: ['Minor Arterial'], PS: ['Collector'] }
  346.                 }
  347.             ],
  348.             information: { Source: 'DDOT', Permission: 'Visible to R4+ or R3-AM' },
  349.             getWhereClause: function (context) {
  350.                 return null;
  351.             },
  352.             getFeatureRoadType: function (feature, layer) {
  353.                 if (layer.getFeatureRoadType) {
  354.                     return layer.getFeatureRoadType(feature);
  355.                 } else {
  356.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  357.                 }
  358.             }
  359.         },
  360.         FL: {
  361.             baseUrl: 'https://services1.arcgis.com/O1JpcwDW8sjYuddV/ArcGIS/rest/services/Functional_Classification_TDA/FeatureServer/',
  362.             supportsPagination: false,
  363.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  364.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  365.             fetchAllFC: false,
  366.             fcMapLayers: [
  367.                 {
  368.                     layerID: 0, fcPropName: 'FUNCLASS', idPropName: 'FID', outFields: ['FID', 'FUNCLASS'], maxRecordCount: 1000, supportsPagination: false,
  369.                     roadTypeMap: { Fw: ['01', '11'], Ew: ['02', '12'], MH: ['04', '14'], mH: ['06', '16'], PS: ['07', '08', '17', '18'] }
  370.                 }
  371.             ],
  372.             information: { Source: 'FDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  373.             getWhereClause: function (context) {
  374.                 return null;
  375.             },
  376.             getFeatureRoadType: function (feature, layer) {
  377.                 if (layer.getFeatureRoadType) {
  378.                     return layer.getFeatureRoadType(feature);
  379.                 } else {
  380.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  381.                 }
  382.             }
  383.         },
  384.         GA: {
  385.             baseUrl: 'https://maps.itos.uga.edu/arcgis/rest/services/GDOT/GDOT_FunctionalClass/mapserver/',
  386.             supportsPagination: true,
  387.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  388.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  389.             fetchAllFC: false,
  390.             fcMapLayers: [
  391.                 { layerID: 0, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  392.                 { layerID: 1, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  393.                 { layerID: 2, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  394.                 { layerID: 3, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  395.                 { layerID: 4, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  396.                 { layerID: 5, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  397.                 { layerID: 6, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } }
  398.             ],
  399.             information: { Source: 'GDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Federal and State highways set to a minimum of mH.' },
  400.             getWhereClause: function (context) {
  401.                 return null;
  402.             },
  403.             getFeatureRoadType: function (feature, layer) {
  404.                 if (layer.getFeatureRoadType) {
  405.                     return layer.getFeatureRoadType(feature);
  406.                 } else {
  407.                     var attr = feature.attributes;
  408.                     var fc = attr.FUNCTIONAL_CLASS;
  409.                     if (attr.SYSTEM_CODE === '1' && fc > 4) {
  410.                         return _stateSettings.global.getRoadTypeFromFC(4, layer);
  411.                     } else {
  412.                         return _stateSettings.global.getFeatureRoadType(feature, layer);
  413.                     }
  414.                 }
  415.             }
  416.         },
  417.         HI: {
  418.             baseUrl: 'http://geodata.hawaii.gov/arcgis/rest/services/Transportation/MapServer/',
  419.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  420.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  421.             fcMapLayers: [
  422.                 {
  423.                     layerID: 12, fcPropName: 'funsystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'funsystem'],
  424.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  425.                 }
  426.             ],
  427.             information: { Source: 'HDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  428.             getWhereClause: function (context) {
  429.                 if (context.mapContext.zoom < 4) {
  430.                     return context.layer.fcPropName + "<>7";
  431.                 } else {
  432.                     return null;
  433.                 }
  434.             },
  435.             getFeatureRoadType: function (feature, layer) {
  436.                 if (layer.getFeatureRoadType) {
  437.                     return layer.getFeatureRoadType(feature);
  438.                 } else {
  439.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  440.                 }
  441.             }
  442.         },
  443.         ID: {
  444.             baseUrl: 'https://gis.itd.idaho.gov/arcgisprod/rest/services/IPLAN/Functional_Classification/MapServer/',
  445.             supportsPagination: false,
  446.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  447.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  448.             fetchAllFC: true,
  449.             fcMapLayers: [
  450.                 { layerID: 0, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  451.                 { layerID: 1, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  452.                 { layerID: 2, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  453.                 { layerID: 3, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  454.                 { layerID: 4, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  455.                 { layerID: 5, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } }
  456.             ],
  457.             information: { Source: 'ITD', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  458.             getWhereClause: function (context) {
  459.                 return null;
  460.             },
  461.             getFeatureRoadType: function (feature, layer) {
  462.                 if (layer.getFeatureRoadType) {
  463.                     return layer.getFeatureRoadType(feature);
  464.                 } else {
  465.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  466.                 }
  467.             }
  468.         },
  469.         IL: {
  470.             baseUrl: 'http://ags10s1.dot.illinois.gov/ArcGIS/rest/services/IRoads/IRoads_64/MapServer/',
  471.             supportsPagination: false,
  472.             defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee', CH: '#ff5e0e' },
  473.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  474.             fcMapLayers: [
  475.                 {
  476.                     layerID: 3, idPropName: 'OBJECTID', fcPropName: 'FC', outFields: ['FC', 'MRK_RT_TYP', 'CH', 'OBJECTID'],
  477.                     roadTypeMap: { Fw: ['1'], Ew: ['2'], MH: ['3'], mH: ['4'], PS: ['5', '6'], St: ['7'] }, maxRecordCount: 1000, supportsPagination: false
  478.                 }
  479.             ],
  480.             isPermitted: function () { return _r >= 4; },
  481.             information: { Source: 'IDOT', Permission: 'Visible to R4+' },
  482.             getWhereClause: function (context) {
  483.                 return context.mapContext.zoom < 4 ? "FC<>7" : null;
  484.             },
  485.             getFeatureRoadType: function (feature, layer) {
  486.                 var attr = feature.attributes;
  487.                 var fc = attr.FC;
  488.                 var type = attr.MRK_RT_TYP;
  489.                 if (fc > 3 && type === 'U') { // US Route
  490.                     fc = 3;
  491.                 } else if (fc > 4 && type === 'S') { // State Route
  492.                     fc = 4;
  493.                 } else if (fc > 6 && attr.CH !== '0000') { // County Route
  494.                     fc = 6;
  495.                 }
  496.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  497.             }
  498.         },
  499.         IN: {
  500.             baseUrl: 'https://gis.in.gov/arcgis/rest/services/DOT/INDOT_LTAP/FeatureServer/',
  501.             supportsPagination: false,
  502.             overrideUrl: '1Sbwc7e6BfHpZWSTfU3_1otXGSxHrdDYcbn7fOf1VjpA',
  503.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  504.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []], hideRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  505.             fcMapLayers: [
  506.                 {
  507.                     layerID: 10, idPropName: 'OBJECTID', fcPropName: 'FUNCTIONAL_CLASS', outFields: ['FUNCTIONAL_CLASS', 'OBJECTID', 'TO_DATE'],
  508.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 100000, supportsPagination: false
  509.                 }
  510.             ],
  511.             isPermitted: function () { return true; },
  512.             information: { Source: 'INDOT', Description: 'Raw unmodified FC data.' },
  513.             getWhereClause: function (context) {
  514.                 var whereParts = ['TO_DATE IS NULL'];
  515.                 if (context.mapContext.zoom < 4) {
  516.                     whereParts += ' AND ' + context.layer.fcPropName + '<>7';
  517.                 }
  518.                 return whereParts;
  519.             },
  520.             getFeatureRoadType: function (feature, layer) {
  521.                 if (layer.getFeatureRoadType) {
  522.                     return layer.getFeatureRoadType(feature);
  523.                 } else {
  524.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  525.                 }
  526.             }
  527.         },
  528.         IA: {
  529.             baseUrl: 'https://gis.iowadot.gov/agshost/rest/services/RAMS/Road_Network/FeatureServer/',
  530.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee', PSGr: '#cc6533', StGr: '#e99cb6' },
  531.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  532.             fcMapLayers: [
  533.                 {
  534.                     layerID: 0, fcPropName: 'FED_FUNCTIONAL_CLASS', idPropName: 'OBJECTID',
  535.                     outFields: ['OBJECTID', 'FED_FUNCTIONAL_CLASS', 'STATE_ROUTE_NAME_1', 'ACCESS_CONTROL', 'SURFACE_TYPE'],
  536.                     roadTypeMap: { Fw: [1], MH: [2, 3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  537.                 }
  538.             ],
  539.             information: { Source: 'Iowa DOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Additional colors denote unpaved PS and LS segements.' },
  540.             getWhereClause: function (context) {
  541.                 var theWhereClause = "FACILITY_TYPE<>'7'"; // Removed proposed roads
  542.                 if (context.mapContext.zoom < 4) {
  543.                     theWhereClause += " AND " + context.layer.fcPropName + "<>'7'";
  544.                 }
  545.                 return theWhereClause;
  546.             },
  547.             getFeatureRoadType: function (feature, layer) {
  548.                 var attr = feature.attributes;
  549.                 var fc = parseInt(attr[layer.fcPropName]);
  550.                 var isFw = attr.ACCESS_CONTROL === 1;
  551.                 var isUS = RegExp('^STATE OF IOWA, US').test(attr.STATE_ROUTE_NAME_1);
  552.                 var isState = RegExp('^STATE OF IOWA, IA').test(attr.STATE_ROUTE_NAME_1);
  553.                 if (isFw) {
  554.                     fc = 1;
  555.                 } else if (fc > 3 && isUS) {
  556.                     fc = 3;
  557.                 } else if (fc > 4 && isState) {
  558.                     fc = 4;
  559.                 }
  560.                 if (fc > 4 && attr.SURFACE_TYPE === 20) {
  561.                     return fc < 7 ? 'PSGr' : 'StGr';
  562.                 } else {
  563.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  564.                 }
  565.             }
  566.         },
  567.         KS: {
  568.             baseUrl: 'http://wfs.ksdot.org/arcgis_web_adaptor/rest/services/Transportation/',
  569.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  570.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  571.             fcMapLayers: [
  572.                 {
  573.                     layerID: 0, layerPath: 'Non_State_System/MapServer/', idPropName: 'ID2', fcPropName: 'FUNCLASS', outFields: ['FUNCLASS', 'ID2', 'ROUTE_ID'],
  574.                     roadTypeMap: { Fw: [1], MH: [2, 3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  575.                 },
  576.                 {
  577.                     layerID: 0, layerPath: 'State_System/MapServer/', idPropName: 'OBJECTID', fcPropName: 'FUN_CLASS_CD', outFields: ['FUN_CLASS_CD', 'OBJECTID', 'PREFIX', 'ACCESS_CONTROL'],
  578.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  579.                 }
  580.             ],
  581.             information: { Source: 'KDOT', Permission: 'Visible to R4+ or R3-AM' },
  582.             getWhereClause: function (context) {
  583.                 if (context.mapContext.zoom < 4) {
  584.                     return context.layer.fcPropName + "<>'7'";
  585.                 } else {
  586.                     return null;
  587.                 }
  588.             },
  589.             getFeatureRoadType: function (feature, layer) {
  590.                 var attr = feature.attributes;
  591.                 var fc = parseInt(attr[layer.fcPropName]);
  592.                 var roadPrefix = attr.PREFIX;
  593.                 var isUS = roadPrefix === 'U';
  594.                 var isState = roadPrefix === 'K';
  595.                 if ((fc > 3 && isUS) || (fc === 2 && parseInt(attr.ACCESS_CONTROL) !== 1)) {
  596.                     fc = 3;
  597.                 } else if (fc > 4 && isState) {
  598.                     fc = 4;
  599.                 }
  600.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  601.             },
  602.         },
  603.         KY: {
  604.             baseUrl: 'https://maps.kytc.ky.gov/arcgis/rest/services/BaseMap/System/MapServer/',
  605.             supportsPagination: false,
  606.             defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  607.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  608.             fcMapLayers: [
  609.                 {
  610.                     layerID: 0, idPropName: 'OBJECTID', fcPropName: 'FC', outFields: ['FC', 'OBJECTID', 'RT_PREFIX', 'RT_SUFFIX'],
  611.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  612.                 }
  613.             ],
  614.             isPermitted: function () { return true; },
  615.             information: { Source: 'KYTC' },
  616.             getWhereClause: function (context) {
  617.                 if (context.mapContext.zoom < 4) {
  618.                     return context.layer.fcPropName + "<>'7'";
  619.                 } else {
  620.                     return null;
  621.                 }
  622.             },
  623.             getFeatureRoadType: function (feature, layer) {
  624.                 var attr = feature.attributes;
  625.                 var fc = parseInt(attr[layer.fcPropName]);
  626.                 if (fc > 3 && attr.RT_PREFIX === 'US') {
  627.                     var suffix = attr.RT_SUFFIX;
  628.                     fc = (suffix && suffix.indexOf('X') > -1) ? 4 : 3;
  629.                 }
  630.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  631.             }
  632.         },
  633.         LA: {
  634.             baseUrl: 'https://giswebnew.dotd.la.gov/arcgis/rest/services/Transportation/LA_RoadwayFunctionalClassification/FeatureServer/',
  635.             supportsPagination: false,
  636.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  637.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  638.             fcMapLayers: [
  639.                 { layerID: 0, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  640.                 { layerID: 1, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  641.                 { layerID: 2, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  642.                 { layerID: 3, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  643.                 { layerID: 4, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  644.                 { layerID: 5, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  645.                 { layerID: 6, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  646.             ],
  647.             information: { Source: 'LaDOTD', Permission: 'Visible to R4+ or R3-AM' },
  648.             getWhereClause: function (context) {
  649.                 if (context.mapContext.zoom < 4) {
  650.                     return context.layer.fcPropName + "<>'7'"; // OR State_Route LIKE 'US%' OR State_Route LIKE 'LA%'";
  651.                 } else {
  652.                     return null;
  653.                 }
  654.             },
  655.             getFeatureRoadType: function (feature, layer) {
  656.                 var fc = feature.attributes[layer.fcPropName];
  657.                 if (fc === '2a' || fc === '2b') { fc = 2; }
  658.                 fc = parseInt(fc);
  659.                 var route = feature.attributes.RouteID.split('_')[1].trim();
  660.                 var isUS = /^US \d/.test(route);
  661.                 var isState = /^LA \d/.test(route);
  662.                 var isBiz = / BUS$/.test(route);
  663.                 if (fc > 3 && isUS) {
  664.                     fc = isBiz ? 4 : 3;
  665.                 } else if (fc > 4 && isState) {
  666.                     fc = isBiz ? 5 : 4;
  667.                 }
  668.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  669.             }
  670.         },
  671.         ME: {
  672.             baseUrl: 'https://arcgisserver.maine.gov/arcgis/rest/services/mdot/MaineDOT_Dynamic/MapServer/',
  673.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  674.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  675.             fcMapLayers: [
  676.                 {
  677.                     layerID: 811, fcPropName: 'fedfunccls', idPropName: 'objectid', outFields: ['objectid', 'fedfunccls', 'prirtename'],
  678.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  679.                 }
  680.             ],
  681.             information: { Source: 'MaineDOT', Permission: 'Visible to R4+ or R3-AM' },
  682.             getWhereClause: function (context) {
  683.                 if (context.mapContext.zoom < 4) {
  684.                     return context.layer.fcPropName + "<>'Local'";
  685.                 } else {
  686.                     return null;
  687.                 }
  688.             },
  689.             getFeatureRoadType: function (feature, layer) {
  690.                 var attr = feature.attributes;
  691.                 var fc = attr[layer.fcPropName];
  692.                 switch (fc) {
  693.                     case 'Princ art interstate': fc = 1; break;
  694.                     case 'Princ art other f&e': fc = 2; break;
  695.                     case 'Other princ arterial': fc = 3; break;
  696.                     case 'Minor arterial': fc = 4; break;
  697.                     case 'Major/urb collector':
  698.                     case 'Minor collector': fc = 5; break;
  699.                     default: fc = 7;
  700.                 }
  701.                 var route = attr.prirtename;
  702.                 var isUS = RegExp(/^US \d/).test(route);
  703.                 var isState = RegExp(/^ST RTE \d/).test(route);
  704.                 var isBiz = (isUS && RegExp(/(1B|1BS)$/).test(route)) || (isState && RegExp(/(15B|24B|25B|137B)$/).test(route));
  705.                 if (fc > 3 && isUS) {
  706.                     fc = isBiz ? 4 : 3;
  707.                 } else if (fc > 4 && isState) {
  708.                     fc = isBiz ? 5 : 4;
  709.                 }
  710.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  711.             }
  712.         },
  713.         MD: {
  714.             baseUrl: 'https://geodata.md.gov/imap/rest/services/Transportation/MD_HighwayPerformanceMonitoringSystem/MapServer/',
  715.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#ffff00', St: '#eeeeee' },
  716.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  717.             fcMapLayers: [
  718.                 { layerID: 2, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'ID_PREFIX', 'MP_SUFFIX'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  719.             ],
  720.             information: { Source: 'MDOT', Permission: 'Visible to R4+ or R3-AM' },
  721.             getWhereClause: function (context) {
  722.                 if (context.mapContext.zoom < 4) {
  723.                     return "(FUNCTIONAL_CLASS < 7 OR ID_PREFIX IN('MD'))";
  724.                 } else {
  725.                     return null;
  726.                 }
  727.             },
  728.             getFeatureRoadType: function (feature, layer) {
  729.                 var attr = feature.attributes;
  730.                 var fc = parseInt(attr.FUNCTIONAL_CLASS);
  731.                 var isUS = attr.ID_PREFIX === 'US';
  732.                 var isState = attr.ID_PREFIX === 'MD';
  733.                 var isBiz = attr.MP_SUFFIX === 'BU';
  734.                 if (fc > 3 && isUS) {
  735.                     fc = isBiz ? 4 : 3;
  736.                 } else if (fc > 4 && isState) {
  737.                     fc = isBiz ? 5 : 4;
  738.                 }
  739.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  740.             }
  741.         },
  742.         MA: {
  743.             baseUrl: 'https://gis.massdot.state.ma.us/arcgis/rest/services/Roads/RoadInventory/MapServer/',
  744.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  745.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  746.             fcMapLayers: [
  747.                 {
  748.                     layerID: 0, fcPropName: 'F_F_Class', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_F_Class', 'Route_ID'],
  749.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  750.                 }
  751.             ],
  752.             information: { Source: 'MDOT', Permission: 'Visible to R4+ or R3-AM' },
  753.             getWhereClause: function (context) {
  754.                 if (context.mapContext.zoom < 4) {
  755.                     return context.layer.fcPropName + "<>'7'";
  756.                 } else {
  757.                     return null;
  758.                 }
  759.             },
  760.             getFeatureRoadType: function (feature, layer) {
  761.                 var attr = feature.attributes;
  762.                 var fc = parseInt(attr[layer.fcPropName]);
  763.                 var route = attr.Route_ID;
  764.                 var isUS = /^US\d/.test(route);
  765.                 var isState = /^SR\d/.test(route);
  766.                 if (fc > 3 && isUS) {
  767.                     fc = 3;
  768.                 } else if (fc > 4 && isState) {
  769.                     fc = 4;
  770.                 }
  771.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  772.             }
  773.         },
  774.         MI: {
  775.             baseUrl: 'https://gisp.mcgi.state.mi.us/arcgis/rest/services/MDOT/NFC/MapServer/',
  776.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  777.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  778.             fcMapLayers: [
  779.                 { layerID: 2, idPropName: 'OBJECTID', fcPropName: 'NFC', outFields: ['NFC'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  780.             ],
  781.             isPermitted: function () { return true; },
  782.             information: { Source: 'MDOT', Description: 'Raw unmodified FC data.' },
  783.             getWhereClause: function (context) {
  784.                 if (context.mapContext.zoom < 4) {
  785.                     return context.layer.fcPropName + '<>7';
  786.                 } else {
  787.                     return null;
  788.                 }
  789.             },
  790.             getFeatureRoadType: function (feature, layer) {
  791.                 if (layer.getFeatureRoadType) {
  792.                     return layer.getFeatureRoadType(feature);
  793.                 } else {
  794.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  795.                 }
  796.             }
  797.         },
  798.         MO: {
  799.             baseUrl: 'http://mapping.modot.org/external/rest/services/BaseMap/TmsUtility/MapServer/',
  800.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  801.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  802.             fcMapLayers: [
  803.                 {
  804.                     layerID: 5, fcPropName: 'FUNC_CLASS_NAME', idPropName: 'SS_PAVEMENT_ID', outFields: ['SS_PAVEMENT_ID', 'FUNC_CLASS_NAME', 'TRAVELWAY_DESG', 'TRAVELWAY_NAME', 'ACCESS_CAT_NAME'],
  805.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  806.                 }
  807.             ],
  808.             isPermitted: function () { return _r >= 3 || (_r >= 2 && _isAM); },
  809.             information: { Source: 'MoDOT', Permission: 'Visible to R3+ or R2-AM' },
  810.             getWhereClause: function (context) {
  811.                 if (context.mapContext.zoom < 1) {
  812.                     return '1=0'; //WME very laggy at zoom 0
  813.                 } else {
  814.                     // Remove duplicate rows, but suss out interstate business loops
  815.                     return "FUNC_CLASS_NAME <> ' ' AND (TRAVELWAY_ID = CNTL_TW_ID OR (TRAVELWAY_ID <> CNTL_TW_ID AND TRAVELWAY_DESG = 'LP'))";
  816.                 }
  817.             },
  818.             getFeatureRoadType: function (feature, layer) {
  819.                 var attr = feature.attributes;
  820.                 var fc = attr[layer.fcPropName];
  821.                 var rtType = attr.TRAVELWAY_DESG;
  822.                 var route = attr.TRAVELWAY_NAME;
  823.                 switch (fc) {
  824.                     case 'INTERSTATE': fc = 1; break;
  825.                     case 'FREEWAY': fc = 2; break;
  826.                     case 'PRINCIPAL ARTERIAL': fc = 3; break;
  827.                     case 'MINOR ARTERIAL': fc = 4; break;
  828.                     case 'MAJOR COLLECTOR': fc = 5; break
  829.                     case 'MINOR COLLECTOR': fc = 6; break;
  830.                     default: fc = 8; // not a typo
  831.                 }
  832.                 var usHwys = ['24', '36', '40', '50', '54', '56', '59', '60', '61', '62', '63', '65', '67', '69', '71', '136', '159', '160', '166', '169', '275', '400', '412'];
  833.                 var isUS = ['US', 'LP'].includes(rtType); // is US or interstate biz
  834.                 var isState = ['MO', 'AL'].includes(rtType);
  835.                 var isSup = rtType === 'RT';
  836.                 var isBiz = ['BU', 'SP'].includes(rtType) || /BUSINESS .+ \d/.test(route);
  837.                 var isUSBiz = isBiz && usHwys.includes(route);
  838.                 if ((fc === 2 && attr.ACCESS_CAT_NAME !== 'FULL') || (fc > 3 && isUS)) {
  839.                     fc = 3;
  840.                 } else if (fc > 4 && (isState || isUSBiz)) {
  841.                     fc = 4;
  842.                 } else if (fc > 6 && (isSup || isBiz)) {
  843.                     fc = 6;
  844.                 }
  845.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  846.             }
  847.         },
  848.         MT: {
  849.             baseUrl: 'https://app.mdt.mt.gov/arcgis/rest/services/Standard/ROUTES/MapServer/',
  850.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  851.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  852.             fcMapLayers: [
  853.                 { layerID: 0, fcPropName: 'FC', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FC', 'SIGN_ROUTE', 'ROUTE_NAME'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  854.                 { layerID: 1, fcPropName: 'FC', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FC', 'SIGN_ROUTE', 'ROUTE_NAME'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  855.             ],
  856.             isPermitted: function () { return _r >= 3; },
  857.             information: { Source: 'MDT', Permission: 'Visible to R3+' },
  858.             getWhereClause: function (context) {
  859.                 if (context.mapContext.zoom < 4) {
  860.                     return context.layer.fcPropName + "<>'LOCAL'";
  861.                 } else {
  862.                     return null;
  863.                 }
  864.             },
  865.             getFeatureRoadType: function (feature, layer) {
  866.                 var fc = feature.attributes.FC;
  867.                 switch (fc) {
  868.                     case 'PRINCIPAL ARTERIAL - INTERSTATE': fc = 1; break;
  869.                     case 'PRINCIPAL ARTERIAL - NON-INTERSTATE': fc = 3; break;
  870.                     case 'MINOR ARTERIAL': fc = 4; break;
  871.                     case 'MAJOR COLLECTOR':
  872.                     case 'MINOR COLLECTOR': fc = 5; break;
  873.                     default: fc = 7;
  874.                 }
  875.                 var roadID = feature.attributes.SIGN_ROUTE;
  876.                 if (!roadID) { roadID = feature.attributes.ROUTE_NAME; }
  877.                 var isUS = RegExp(/^US \d+/).test(roadID);
  878.                 var isState = RegExp(/^MONTANA \d+|ROUTE \d+|S \d{3}\b/).test(roadID);
  879.                 if (fc > 3 && isUS) { fc = 3; }
  880.                 else if (fc > 4 && isState) { fc = 4; }
  881.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  882.             }
  883.         },
  884.         NH: {
  885.             baseUrl: 'https://nhgeodata.unh.edu/nhgeodata/rest/services/GRANITView/GV_BaseLayers/MapServer/',
  886.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  887.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  888.             fcMapLayers: [
  889.                 {
  890.                     layerID: 18, fcPropName: 'FUNCT_SYSTEM', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCT_SYSTEM', 'STREET_ALIASES', 'TIER'],
  891.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [2, 3], mH: [4], PS: [5, 6], St: [7, 0] }, maxRecordCount: 1000, supportsPagination: false
  892.                 }
  893.             ],
  894.             isPermitted: function () { return _r >= 3; },
  895.             information: { Source: 'NH GRANIT', Permission: 'Visible to R3+' },
  896.             getWhereClause: function (context) {
  897.                 if (context.mapContext.zoom < 4) {
  898.                     return context.layer.fcPropName + "<>7 AND " + context.layer.fcPropName + "<>0";
  899.                 } else {
  900.                     return null;
  901.                 }
  902.             },
  903.             getFeatureRoadType: function (feature, layer) {
  904.                 var fc = parseInt(feature.attributes[layer.fcPropName]);
  905.                 if (!(fc > 0)) { fc = 7; }
  906.                 var route = feature.attributes.STREET_ALIASES;
  907.                 var isUS = RegExp(/US /).test(route);
  908.                 var isState = RegExp(/NH /).test(route);
  909.                 if (fc === 2) { feature.attributes.TIER === 1 ? fc = 1 : fc = 3; }
  910.                 else if (fc > 3 && isUS) { RegExp(/US 3B/).test(route) ? fc = 4 : fc = 3; }
  911.                 else if (fc > 4 && isState) { fc = 4; }
  912.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  913.             }
  914.         },
  915.         NM: {
  916.             baseUrl: 'https://services.arcgis.com/hOpd7wfnKm16p9D9/ArcGIS/rest/services/NMDOT_Functional_Class/FeatureServer/',
  917.             defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  918.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  919.             fcMapLayers: [
  920.                 {
  921.                     layerID: 0, fcPropName: 'Func_Class', idPropName: 'OBJECTID_1', maxRecordCount: 1000, supportsPagination: false,
  922.                     outFields: ['OBJECTID_1', 'Func_Class', 'D_RT_ROUTE'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  923.                 }
  924.             ],
  925.             isPermitted: function () { return true; },
  926.             information: { Source: 'NMDOT' },
  927.             getWhereClause: function (context) {
  928.                 return null;
  929.             },
  930.             getFeatureRoadType: function (feature, layer) {
  931.                 var fc = parseInt(feature.attributes[layer.fcPropName]);
  932.                 var roadType = feature.attributes.D_RT_ROUTE.split('-', 1).shift();
  933.                 var isBiz = roadType === 'BL'; // Interstate Business Loop
  934.                 var isUS = roadType === 'US';
  935.                 var isState = roadType === 'NM';
  936.                 if (roadType === 'IX') { fc = 0; }
  937.                 else if (fc > 3 && (isBiz || isUS)) { fc = 3; }
  938.                 else if (fc > 4 && isState) { fc = 4; }
  939.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  940.             }
  941.         },
  942.         NY: {//https://gis.dot.ny.gov/hostingny/rest/services/Basemap/MapServer/21
  943.             baseUrl: 'https://gis.dot.ny.gov/hostingny/rest/services',
  944.             defaultColors: { Fw: '#ff00c5', Ew: '#5f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  945.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  946.             fcMapLayers: [
  947.                 {
  948.                     layerID: '/Geocortex/FC/MapServer/1', fcPropName: 'FUNC_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNC_CLASS', 'SEGMENT_NAME', 'ROUTE_NO'], roadTypeMap: { Fw: [1, 11], Ew: [2, 12], MH: [4, 14], mH: [6, 16], PS: [7, 8, 17, 18] },
  949.                     maxRecordCount: 1000, supportsPagination: false
  950.                 },
  951.                 { layerID: 'Basemap/MapServer/21', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'SHIELD'], maxRecordCount: 1000, supportsPagination: false }
  952.             ],
  953.             information: { Source: 'NYSDOT', Permission: 'Visible to R4+ or R3-AM' },
  954.             getWhereClause: function (context) {
  955.                 if (context.layer.layerID === 'Basemap/MapServer/21') {
  956.                     return ("SHIELD IN ('C','CT')");
  957.                 } else {
  958.                     return null;
  959.                 }
  960.             },
  961.             getFeatureRoadType: function (feature, layer) {
  962.                 var roadType;
  963.                 if (layer.layerID === 'Basemap/MapServer/21') {
  964.                     roadType = 'PS';
  965.                 } else {
  966.                     roadType = _stateSettings.global.getFeatureRoadType(feature, layer);
  967.                     var routeNo = feature.attributes.ROUTE_NO;
  968.                     if (/^NY.*/.test(routeNo)) {
  969.                         if (roadType === 'PS') roadType = 'mH';
  970.                     } else if (/^US.*/.test(routeNo)) {
  971.                         if (roadType === 'PS' || roadType === 'mH') roadType = 'MH';
  972.                     }
  973.                 }
  974.                 return roadType;
  975.             }
  976.         },
  977.         NC: {
  978.             baseUrl: 'https://gis11.services.ncdot.gov/arcgis/rest/services/NCDOT_FunctionalClassQtr/MapServer/',
  979.             defaultColors: { Fw: '#ff00c5', Rmp: '#999999', Ew: '#5f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  980.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  981.             fcMapLayers: [
  982.                 { layerID: 0, fcPropName: 'FuncClass', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FuncClass', 'RouteClass', 'RouteQualifier'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, zoomLevels: [3, 4, 5, 6, 7, 8, 9, 10], maxRecordCount: 1000, supportsPagination: false }
  983.                 //{ layerID:2, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[2], maxRecordCount:1000, supportsPagination:false },
  984.                 //{ layerID:3, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[0,1], maxRecordCount:1000, supportsPagination:false },
  985.                 //{ layerID:4, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false },
  986.                 //{ layerID:5, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false },
  987.                 //{ layerID:6, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false }
  988.             ],
  989.             isPermitted: function () { return _r >= 3; },
  990.             information: { Source: 'NCDOT', Permission: 'Visible to R3+' },
  991.             getWhereClause: function (context) {
  992.                 if (context.mapContext.zoom < 4) {
  993.                     var clause = '(' + context.layer.fcPropName + " < 7 OR RouteClass IN ('I','FED','NC','RMP','US'))";
  994.                     return clause;
  995.                 } else {
  996.                     return null;
  997.                 }
  998.             },
  999.             getFeatureRoadType: function (feature, layer) {
  1000.                 var fc = feature.attributes[layer.fcPropName];
  1001.                 var roadType;
  1002.                 switch (this.getHwySys(feature)) {
  1003.                     case 'interstate':
  1004.                         if (fc <= 2 || !this.isBusinessRoute(feature)) {
  1005.                             roadType = 'Fw';
  1006.                         } else {
  1007.                             roadType = 'MH';
  1008.                         }
  1009.                         break;
  1010.                     case 'us':
  1011.                         if (fc <= 2) {
  1012.                             roadType = 'Ew';
  1013.                         } else if (fc === 3 || !this.isBusinessRoute(feature)) {
  1014.                             roadType = 'MH';
  1015.                         } else {
  1016.                             roadType = 'mH';
  1017.                         }
  1018.                         break;
  1019.                     case 'state':
  1020.                         if (fc <= 2) {
  1021.                             roadType = 'Ew';
  1022.                         } else if (fc === 3) {
  1023.                             roadType = 'MH';
  1024.                         } else if (fc === 4 || !this.isBusinessRoute(feature)) {
  1025.                             roadType = 'mH';
  1026.                         } else {
  1027.                             roadType = 'PS';
  1028.                         }
  1029.                         break;
  1030.                     case 'ramp':
  1031.                         roadType = 'Rmp';
  1032.                         break;
  1033.                     default:
  1034.                         roadType = fc === 2 ? 'Ew' : (fc === 3 ? 'MH' : (fc === 4 ? 'mH' : (fc <= 6 ? 'PS' : 'St')));
  1035.                 }
  1036.                 return roadType;
  1037.             },
  1038.             getHwySys: function (feature) {
  1039.                 var hwySys;
  1040.                 switch (feature.attributes.RouteClass.toString()) {
  1041.                     case '1':
  1042.                         hwySys = 'interstate';
  1043.                         break;
  1044.                     case '2':
  1045.                         hwySys = 'us';
  1046.                         break;
  1047.                     case '3':
  1048.                         hwySys = 'state';
  1049.                         break;
  1050.                     case '80':
  1051.                         hwySys = 'ramp';
  1052.                         break;
  1053.                     default:
  1054.                         hwySys = 'local';
  1055.                 }
  1056.                 return hwySys;
  1057.             },
  1058.             isBusinessRoute: function (feature) {
  1059.                 var qual = feature.attributes.RouteQualifier.toString();
  1060.                 return qual === '9';
  1061.             }
  1062.         },
  1063.         ND: {
  1064.             baseUrl: 'https://gis.dot.nd.gov/arcgis/rest/services/external/transinfo/MapServer/',
  1065.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1066.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1067.             fcMapLayers: [
  1068.                 {
  1069.                     layerID: 10, fcPropName: 'FUNCTION_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTION_CLASS'], roadTypeMap: { Fw: ['Interstate'], MH: ['Principal Arterial'], mH: ['Minor Arterial'], PS: ['Major Collector', 'Collector'], St: ['Local'] },
  1070.                     maxRecordCount: 1000, supportsPagination: false
  1071.                 },
  1072.                 {
  1073.                     layerID: 11, fcPropName: 'FUNCTION_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTION_CLASS'], roadTypeMap: { Fw: ['Interstate'], MH: ['Principal Arterial'], mH: ['Minor Arterial'], PS: ['Major Collector', 'Collector'], St: ['Local'] },
  1074.                     maxRecordCount: 1000, supportsPagination: false
  1075.                 },
  1076.                 {
  1077.                     layerID: 12, fcPropName: 'FUNCTION_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTION_CLASS'], roadTypeMap: { PS: ['Major Collector', 'Collector'] },
  1078.                     maxRecordCount: 1000, supportsPagination: false
  1079.                 },
  1080.                 {
  1081.                     layerID: 16, fcPropName: 'SYSTEM_CD', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'SYSTEM_CD', 'SYSTEM_DESC', 'HIGHWAY', 'HWY_SUFFIX'], roadTypeMap: { Fw: [1, 11], MH: [2, 14], mH: [6, 7, 16, 19] },
  1082.                     maxRecordCount: 1000, supportsPagination: false
  1083.                 }
  1084.             ],
  1085.             information: { Source: 'NDDOT', Permission: 'Visible to R4+ or R3-AM' },
  1086.             getWhereClause: function (context) {
  1087.                 if (context.mapContext.zoom < 4) {
  1088.                     if (context.layer.layerID !== 16) return context.layer.fcPropName + "<>'Local'";
  1089.                 } else {
  1090.                     return null;
  1091.                 }
  1092.             },
  1093.             getFeatureRoadType: function (feature, layer) {
  1094.                 return _stateSettings.global.getFeatureRoadType(feature, layer);
  1095.             }
  1096.         },
  1097.         OH: {
  1098.             baseUrl: 'https://gis.dot.state.oh.us/arcgis/rest/services/TIMS/Roadway_Information/MapServer/',
  1099.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1100.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1101.  
  1102.             fcMapLayers: [
  1103.                 {
  1104.                     layerID: 8, fcPropName: 'FUNCTION_CLASS', idPropName: 'ObjectID', outFields: ['FUNCTION_CLASS', 'ROUTE_TYPE', 'ROUTE_NBR', 'ObjectID'],
  1105.                     maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1106.                 }
  1107.             ],
  1108.             isPermitted: function () { return true; },
  1109.             information: { Source: 'ODOT' },
  1110.             getWhereClause: function (context) {
  1111.                 if (context.mapContext.zoom < 4) {
  1112.                     var clause = '(' + context.layer.fcPropName + " < 7 OR ROUTE_TYPE IN ('CR','SR','US'))";
  1113.                     return clause;
  1114.                 } else {
  1115.                     return null;
  1116.                 }
  1117.             },
  1118.             getFeatureRoadType: function (feature, layer) {
  1119.                 var fc = feature.attributes[layer.fcPropName];
  1120.                 var prefix = feature.attributes.ROUTE_TYPE;
  1121.                 var isUS = prefix === 'US';
  1122.                 var isState = prefix === 'SR';
  1123.                 var isCounty = prefix === 'CR';
  1124.                 if (isUS && fc > 3) { fc = 3; }
  1125.                 if (isState && fc > 4) { fc = 4; }
  1126.                 if (isCounty && fc > 6) { fc = 6; }
  1127.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1128.             }
  1129.         },
  1130.         OK: {
  1131.             baseUrl: 'https://services6.arcgis.com/RBtoEUQ2lmN0K3GY/arcgis/rest/services/Roadways/FeatureServer/',
  1132.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1133.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1134.             fcMapLayers: [
  1135.                 {
  1136.                     layerID: 0, fcPropName: 'FUNCTIONALCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONALCLASS', 'FHWAPRIMARYROUTE', 'ODOTROUTECLASS', 'ACCESSCONTROL'],
  1137.                     maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1138.                 }
  1139.             ],
  1140.             information: { Source: 'ODOT', Permission: 'Visible to R4+ or R3-AM' },
  1141.             getWhereClause: function (context) {
  1142.                 if (context.mapContext.zoom < 4) {
  1143.                     return context.layer.fcPropName + " < 7 OR ODOTROUTECLASS IN ('U','S','I')";
  1144.                 } else {
  1145.                     return null;
  1146.                 }
  1147.             },
  1148.             getFeatureRoadType: function (feature, layer) {
  1149.                 var fc = feature.attributes[layer.fcPropName];
  1150.                 var route = (feature.attributes.FHWAPRIMARYROUTE || '').trim();
  1151.                 var isBusinessOrSpur = /BUS$|SPR$/i.test(route);
  1152.                 var prefix = isBusinessOrSpur ? route.substring(0, 1) : feature.attributes.ODOTROUTECLASS;
  1153.                 var isFw = parseInt(feature.attributes.ACCESSCONTROL) === 1;
  1154.                 var isInterstate = prefix === 'I';
  1155.                 var isUS = prefix === 'U';
  1156.                 var isState = prefix === 'S';
  1157.                 if (isFw) { fc = 1; }
  1158.                 else if (fc > 3 && ((isUS && !isBusinessOrSpur) || (isInterstate && isBusinessOrSpur))) { fc = 3; }
  1159.                 else if (fc > 4 && ((isUS && isBusinessOrSpur) || (isState && !isBusinessOrSpur))) { fc = 4; }
  1160.                 else if (fc > 5 && isState && isBusinessOrSpur) { fc = 5; }
  1161.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1162.             }
  1163.         },
  1164.         OR: {
  1165.             baseUrl: 'https://gis.odot.state.or.us/arcgis/rest/services/transgis/data_catalog_display/Mapserver/',
  1166.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1167.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1168.             fcMapLayers: [
  1169.                 {
  1170.                     layerID: 78, fcPropName: 'NEW_FC_CD', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'NEW_FC_CD'],
  1171.                     roadTypeMap: { Fw: ['1'], Ew: ['2'], MH: ['3'], mH: ['4'], PS: ['5', '6'], St: ['7'] }, maxRecordCount: 1000, supportsPagination: false
  1172.                 },
  1173.                 {
  1174.                     layerID: 80, fcPropName: 'NEW_FC_CD', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'NEW_FC_CD'],
  1175.                     roadTypeMap: { Fw: ['1'], Ew: ['2'], MH: ['3'], mH: ['4'], PS: ['5', '6'], St: ['7'] }, maxRecordCount: 1000, supportsPagination: false
  1176.                 }
  1177.             ],
  1178.             information: { Source: 'ODOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  1179.             getWhereClause: function (context) {
  1180.                 if (context.mapContext.zoom < 4) {
  1181.                     return context.layer.fcPropName + " <> '7'";
  1182.                 } else {
  1183.                     return null;
  1184.                 }
  1185.             },
  1186.             getFeatureRoadType: function (feature, layer) {
  1187.                 if (layer.getFeatureRoadType) {
  1188.                     return layer.getFeatureRoadType(feature);
  1189.                 } else {
  1190.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  1191.                 }
  1192.             }
  1193.         },
  1194.         PA: {
  1195.             baseUrl: 'https://gis.penndot.gov/arcgis/rest/services/opendata/roadwayadmin/MapServer/',
  1196.             supportsPagination: false,
  1197.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1198.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1199.             fcMapLayers: [
  1200.                 {
  1201.                     layerID: 0, features: new Map(), fcPropName: 'FUNC_CLS', idPropName: 'MSLINK', outFields: ['MSLINK', 'FUNC_CLS'],
  1202.                     maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: ['01', '11'], Ew: ['12'], MH: ['02', '14'], mH: ['06', '16'], PS: ['07', '08', '17'], St: ['09', '19'] }
  1203.                 }
  1204.             ],
  1205.             isPermitted: function () { return _r >= 4; },
  1206.             information: { Source: 'PennDOT', Permission: 'Visible to R4+', Description: 'Raw unmodified FC data.' },
  1207.             getWhereClause: function (context) {
  1208.                 return (context.mapContext.zoom < 4) ? context.layer.fcPropName + " NOT IN ('09','19')" : null;
  1209.             },
  1210.             getFeatureRoadType: function (feature, layer) {
  1211.                 if (layer.getFeatureRoadType) {
  1212.                     return layer.getFeatureRoadType(feature);
  1213.                 } else {
  1214.                     var fc = feature.attributes[layer.fcPropName];
  1215.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1216.                 }
  1217.             }
  1218.         },
  1219.         RI: {
  1220.             baseUrl: 'https://services2.arcgis.com/S8zZg9pg23JUEexQ/arcgis/rest/services/RIDOT_Roads_2016/FeatureServer/',
  1221.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1222.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  1223.             fcMapLayers: [
  1224.                 {
  1225.                     layerID: 0, fcPropName: 'F_SYSTEM', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_SYSTEM', 'ROADTYPE', 'RTNO'],
  1226.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7, 0] }, maxRecordCount: 1000, supportsPagination: false
  1227.                 }
  1228.             ],
  1229.             isPermitted: function () { return _r >= 3; },
  1230.             information: { Source: 'RIDOT', Permission: 'Visible to R3+' },
  1231.             getWhereClause: function (context) {
  1232.                 return (context.mapContext.zoom < 4) ? context.layer.fcPropName + " NOT IN (7,0)" : null;
  1233.             },
  1234.             getFeatureRoadType: function (feature, layer) {
  1235.                 var fc = parseInt(feature.attributes[layer.fcPropName]);
  1236.                 var type = feature.attributes.ROADTYPE;
  1237.                 var rtnum = feature.attributes.RTNO;
  1238.                 if (fc === 2 && ['10', '24', '37', '78', '99', '138', '403'].includes(rtnum)) { fc = 1; } //isFw
  1239.                 else if ((fc > 3 && type === 'US') || rtnum === '1') { fc = 3; } //isUS
  1240.                 else if (fc > 4 && rtnum.trim() !== '') { fc = 4; } //isState
  1241.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1242.             }
  1243.         },
  1244.         SC: {
  1245.             baseUrl: 'https://services1.arcgis.com/VaY7cY9pvUYUP1Lf/arcgis/rest/services/Functional_Class/FeatureServer/',
  1246.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1247.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1248.             fcMapLayers: [
  1249.                 {
  1250.                     layerID: 0, fcPropName: 'FC_GIS', idPropName: 'FID', outFields: ['FID', 'FC_GIS', 'ROUTE_LRS'],
  1251.                     maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1252.                 }
  1253.             ],
  1254.             isPermitted: function () { return _r >= 4; },
  1255.             information: { Source: 'SCDOT', Permission: 'Visible to R4+' },
  1256.             getWhereClause: function (context) {
  1257.                 return null;
  1258.             },
  1259.             getFeatureRoadType: function (feature, layer) {
  1260.                 var roadID = feature.attributes.ROUTE_LRS;
  1261.                 var roadType = parseInt(roadID.slice(3, 4));
  1262.                 var isFw = roadType === 1;
  1263.                 var isUS = roadType === 2;
  1264.                 var isState = roadType === 4;
  1265.                 var isBiz = parseInt(roadID.slice(-2, -1)) === 7;
  1266.                 var fc = 7;
  1267.                 switch (feature.attributes[layer.fcPropName]) {
  1268.                     case 'INT': fc = 1; break;
  1269.                     case 'EXP': fc = 2; break;
  1270.                     case 'PRA': fc = 3; break;
  1271.                     case 'MIA': fc = 4; break;
  1272.                     case 'MAC':
  1273.                     case 'MIC': fc = 5; break;
  1274.                 }
  1275.                 if (fc > 1 && isFw) {
  1276.                     fc = 1;
  1277.                 } else if (fc > 3 && isUS) {
  1278.                     fc = isBiz ? 4 : 3;
  1279.                 } else if (fc > 4 && isState) {
  1280.                     fc = (isBiz ? 5 : 4);
  1281.                 }
  1282.                 if (layer.getFeatureRoadType) {
  1283.                     return layer.getFeatureRoadType(feature);
  1284.                 } else {
  1285.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1286.                 }
  1287.             }
  1288.         },
  1289.         SD: {
  1290.             baseUrl: 'https://arcgis.sd.gov/arcgis/rest/services/DOT/LocalRoads/MapServer/',
  1291.             defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee', PSGr: '#cc6533', StGr: '#e99cb6' },
  1292.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1293.             fcMapLayers: [{
  1294.                 layerID: 1, fcPropName: 'FUNC_CLASS', idPropName: 'OBJECTID', maxRecordCount: 1000, supportsPagination: false,
  1295.                 outFields: ['OBJECTID', 'FUNC_CLASS', 'SURFACE_TYPE', 'ROADNAME'],
  1296.                 roadTypeMap: { Fw: [1, 11], Ew: [2, 12], MH: [4, 14], mH: [6, 16], PS: [7, 8, 17], St: [9, 19] }
  1297.             }],
  1298.             information: { Source: 'SDDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Additional colors denote unpaved PS and LS segements.' },
  1299.             getWhereClause: function (context) {
  1300.                 if (context.mapContext.zoom < 4) {
  1301.                     return context.layer.fcPropName + " NOT IN (9,19)";
  1302.                 } else {
  1303.                     return null;
  1304.                 }
  1305.             },
  1306.             getFeatureRoadType: function (feature, layer) {
  1307.                 var attr = feature.attributes;
  1308.                 var fc = parseInt(attr[layer.fcPropName]) % 10;
  1309.                 var isFw = attr.ACCESS_CONTROL === 1;
  1310.                 var isUS = RegExp('^US HWY ', 'i').test(attr.ROADNAME);
  1311.                 var isState = RegExp('^SD HWY ', 'i').test(attr.ROADNAME);
  1312.                 var isBiz = RegExp('^(US|SD) HWY .* (E|W)?(B|L)$', 'i').test(attr.ROADNAME);
  1313.                 var isPaved = parseInt(attr.SURFACE_TYPE) > 5;
  1314.                 if (isFw) {
  1315.                     fc = 1;
  1316.                 } else if (fc > 4 && isUS) {
  1317.                     fc = (isBiz ? 6 : 4);
  1318.                 } else if (fc > 6 && isState) {
  1319.                     fc = (isBiz ? 7 : 6);
  1320.                 }
  1321.                 if (fc > 6 && !isPaved) {
  1322.                     return fc < 9 ? 'PSGr' : 'StGr';
  1323.                 } else {
  1324.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1325.                 }
  1326.             }
  1327.         },
  1328.         TN: {
  1329.             baseUrl: 'https://',
  1330.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', PS2: '#cfae0e', St: '#eeeeee' },
  1331.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  1332.             fcMapLayers: [
  1333.                 {
  1334.                     layerPath: 'testuasiportal.shelbycountytn.gov/arcgis/rest/services/MPO/Webmap_2015_04_20_TMPO/MapServer/', maxRecordCount: 1000, supportsPagination: false,
  1335.                     layerID: 17, fcPropName: 'FuncClass', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FuncClass'],
  1336.                     roadTypeMap: { Fw: [1, 11], Ew: [2, 12], MH: [4, 14], mH: [6, 16], PS: [7, 17], PS2: [8, 18], St: [9, 19] }
  1337.                 },
  1338.                 {
  1339.                     layerPath: 'services3.arcgis.com/pXGyp7DHTIE4RXOJ/ArcGIS/rest/services/Functional_Classification/FeatureServer/', maxRecordCount: 1000, supportsPagination: false,
  1340.                     layerID: 0, fcPropName: 'FC_MPO', idPropName: 'FID', outFields: ['FID', 'FC_MPO'],
  1341.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1342.                 }
  1343.             ],
  1344.             information: {
  1345.                 Source: 'Shelby County, Nashville Area MPO', Permission: 'Visible to R4+ or R3-AM',
  1346.                 Description: 'Raw unmodified FC data for the Memphis and Nashville regions only.'
  1347.             },
  1348.             getWhereClause: function (context) {
  1349.                 if (context.mapContext.zoom < 4) {
  1350.                     return context.layer.fcPropName + ' NOT IN (0,7,9,19)';
  1351.                 } else {
  1352.                     return context.layer.fcPropName + ' <> 0';
  1353.                 }
  1354.             },
  1355.             getFeatureRoadType: function (feature, layer) {
  1356.                 if (layer.getFeatureRoadType) {
  1357.                     return layer.getFeatureRoadType(feature);
  1358.                 } else {
  1359.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  1360.                 }
  1361.             }
  1362.         },
  1363.         TX: {
  1364.             baseUrl: 'https://services.arcgis.com/KTcxiTD9dsQw4r7Z/ArcGIS/rest/services/TxDOT_Functional_Classification/FeatureServer/',
  1365.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1366.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  1367.             fcMapLayers: [
  1368.                 { layerID: 0, fcPropName: 'F_SYSTEM', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_SYSTEM', 'RTE_PRFX'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } }
  1369.             ],
  1370.             isPermitted: function () { return _r >= 2; },
  1371.             information: { Source: 'TxDOT', Permission: 'Visible to R2+' },
  1372.             getWhereClause: function (context) {
  1373.                 var where = " F_SYSTEM IS NOT NULL AND RTE_PRFX IS NOT NULL";
  1374.                 if (context.mapContext.zoom < 4) {
  1375.                     where += ' AND ' + context.layer.fcPropName + " <> 7";
  1376.                 }
  1377.                 return where;
  1378.             },
  1379.             getFeatureRoadType: function (feature, layer) {
  1380.                 // On-System:
  1381.                 // IH=Interstate BF=Business FM
  1382.                 // US=US Highway FM=Farm to Mkt
  1383.                 // UA=US Alt. RM=Ranch to Mkt
  1384.                 // UP=US Spur RR=Ranch Road
  1385.                 // SH=State Highway PR=Park Road
  1386.                 // SA=State Alt. RE=Rec Road
  1387.                 // SL=State Loop RP=Rec Rd Spur
  1388.                 // SS=State Spur FS=FM Spur
  1389.                 // BI=Business IH RS=RM Spur
  1390.                 // BU=Business US RU=RR Spur
  1391.                 // BS=Business State PA=Principal Arterial
  1392.                 // Off-System:
  1393.                 // TL=Off-System Tollroad CR=County Road
  1394.                 // FC=Func. Classified St. LS=Local Street
  1395.                 if (layer.getFeatureRoadType) {
  1396.                     return layer.getFeatureRoadType(feature);
  1397.                 } else {
  1398.                     var fc = feature.attributes[layer.fcPropName];
  1399.                     var type = feature.attributes.RTE_PRFX.substring(0, 2).toUpperCase();
  1400.                     if (type === 'IH' && fc > 1) {
  1401.                         fc = 1;
  1402.                     } else if ((type === 'US' || type === 'BI' || type === 'UA') && fc > 3) {
  1403.                         fc = 3;
  1404.                     } else if ((type === 'UP' || type === 'BU' || type === 'SH' || type === 'SA') && fc > 4) {
  1405.                         fc = 4;
  1406.                     } else if ((type === 'SL' || type === 'SS' || type === 'BS') && fc > 6) {
  1407.                         fc = 6;
  1408.                     }
  1409.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1410.                 }
  1411.             }
  1412.         },
  1413.         UT: {
  1414.             baseUrl: 'https://maps.udot.utah.gov/arcgis/rest/services/Functional_Class/MapServer/',
  1415.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1416.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1417.             fcMapLayers: [
  1418.                 {
  1419.                     layerID: 0, fcPropName: 'FC_CODE', idPropName: 'OBJECTID', outFields: ['*'/*'OBJECTID','FC_CODE'*/], roadTypeMap: { Fw: [1], Ew: [2, 20], MH: [3, 30], mH: [4, 40], PS: [5, 50, 6, 60], St: [7, 77] },
  1420.                     maxRecordCount: 1000, supportsPagination: false
  1421.                 }
  1422.             ],
  1423.             information: { Source: 'TxDOT', Permission: 'Visible to R4+ or R3-AM' },
  1424.             getWhereClause: function (context) {
  1425.                 var clause = context.layer.fcPropName + '<=7';
  1426.                 if (context.mapContext.zoom < 4) {
  1427.                     clause += ' OR ' + context.layer.fcPropName + '<7';
  1428.                 }
  1429.                 return clause;
  1430.             },
  1431.             getFeatureRoadType: function (feature, layer) {
  1432.                 var routeId = feature.attributes.ROUTE_ID;
  1433.                 var fc = feature.attributes.FC_CODE;
  1434.                 if ([6, 40, 50, 89, 91, 163, 189, 191, 491].indexOf(routeId) > -1 && fc > 3) {
  1435.                     // US highway
  1436.                     fc = 3;
  1437.                 } else if (routeId <= 491 && fc > 4) {
  1438.                     // State highway
  1439.                     fc = 4;
  1440.                 }
  1441.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1442.             }
  1443.         },
  1444.         VT: {
  1445.             baseUrl: 'https://maps.vtrans.vermont.gov/arcgis/rest/services/Master/General/FeatureServer/',
  1446.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1447.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1448.             fcMapLayers: [
  1449.                 {
  1450.                     layerID: 39, fcPropName: 'FUNCL', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCL', 'HWYSIGN'],
  1451.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1452.                 }
  1453.             ],
  1454.             information: { Source: 'TxDOT', Permission: 'Visible to R4+ or R3-AM' },
  1455.             getWhereClause: function (context) {
  1456.                 if (context.mapContext.zoom < 4) {
  1457.                     return context.layer.fcPropName + "<>7 AND " + context.layer.fcPropName + "<>0";
  1458.                 } else {
  1459.                     return null;
  1460.                 }
  1461.             },
  1462.             getFeatureRoadType: function (feature, layer) {
  1463.                 var roadID = feature.attributes.HWYSIGN;
  1464.                 var fc = feature.attributes[layer.fcPropName];
  1465.                 if (!(fc > 0)) { fc = 7; }
  1466.                 var isUS = RegExp(/^U/).test(roadID);
  1467.                 var isState = RegExp(/^V/).test(roadID);
  1468.                 var isUSBiz = RegExp(/^B/).test(roadID);
  1469.                 if (fc > 3 && isUS) {
  1470.                     fc = 3;
  1471.                 } else if (fc > 4 && (isUSBiz || isState)) {
  1472.                     fc = 4;
  1473.                 }
  1474.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1475.             }
  1476.         },
  1477.         VA: {
  1478.             baseUrl: 'https://services.arcgis.com/p5v98VHDX9Atv3l7/arcgis/rest/services/FC_2014_FHWA_Submittal1/FeatureServer/',
  1479.             defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1480.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1481.             fcMapLayers: [
  1482.                 { layerID: 0, fcPropName: 'FUNCTIONAL_CLASS_ID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS_ID', 'RTE_NM'], maxRecordCount: 2000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } },
  1483.                 { layerID: 1, fcPropName: 'STATE_FUNCT_CLASS_ID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'STATE_FUNCT_CLASS_ID', 'RTE_NM', 'ROUTE_NO'], maxRecordCount: 2000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } },
  1484.                 { layerID: 3, fcPropName: 'TMPD_FC', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'TMPD_FC', 'RTE_NM'], maxRecordCount: 2000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } }
  1485.             ],
  1486.             information: { Source: 'VDOT', Permission: 'Visible to R4+ or R3-AM' },
  1487.             srExceptions: [217, 302, 303, 305, 308, 310, 313, 314, 315, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 339, 341, 342, 343, 344, 345, 346, 347, 348, 350, 353, 355, 357, 358, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 396, 397, 398, 399, 785, 895],
  1488.             getWhereClause: function (context) {
  1489.                 if (context.mapContext.zoom < 4) {
  1490.                     return context.layer.fcPropName + '<>7';
  1491.                 } else {
  1492.                     //NOTE: As of 9/14/2016 there does not appear to be any US/SR/VA labeled routes with FC = 7.
  1493.                     return null;
  1494.                 }
  1495.             },
  1496.             getFeatureRoadType: function (feature, layer) {
  1497.                 if (layer.getFeatureRoadType) {
  1498.                     return layer.getFeatureRoadType(feature);
  1499.                 } else {
  1500.                     var fc = parseInt(feature.attributes[layer.fcPropName]);
  1501.                     var rtName = feature.attributes.RTE_NM;
  1502.                     var match = /^R-VA\s*(US|VA|SR)(\d{5})..(BUS)?/.exec(rtName);
  1503.                     var isBusiness = (match && (match !== null) && (match[3] === 'BUS'));
  1504.                     var isState = (match && (match !== null) && (match[1] === 'VA' || match[1] === 'SR'));
  1505.                     var rtNum = parseInt((layer.layerID === 1) ? feature.attributes.ROUTE_NO : (match ? match[2] : 99999));
  1506.                     var rtPrefix = match && match[1];
  1507.                     if (fc > 3 && rtPrefix === 'US') {
  1508.                         fc = isBusiness ? 4 : 3;
  1509.                     } else if (isState && fc > 4 && this.srExceptions.indexOf(rtNum) === -1 && rtNum < 600) {
  1510.                         fc = isBusiness ? 5 : 4;
  1511.                     }
  1512.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1513.                 }
  1514.             }
  1515.         },
  1516.         WA: {
  1517.             baseUrl: 'https://data.wsdot.wa.gov/arcgis/rest/services/FunctionalClass/WSDOTFunctionalClassMap/MapServer/',
  1518.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1519.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1520.             fcMapLayers: [
  1521.                 {
  1522.                     layerID: 2, fcPropName: 'FederalFunctionalClassCode', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FederalFunctionalClassCode'],
  1523.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1524.                 },
  1525.                 {
  1526.                     layerID: 1, fcPropName: 'FederalFunctionalClassCode', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FederalFunctionalClassCode'],
  1527.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1528.                 },
  1529.                 {
  1530.                     layerID: 4, fcPropName: 'FederalFunctionalClassCode', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FederalFunctionalClassCode'],
  1531.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1532.                 }
  1533.             ],
  1534.             information: { Source: 'WSDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  1535.             getWhereClause: function (context) {
  1536.                 if (context.mapContext.zoom < 4) {
  1537.                     return context.layer.fcPropName + " <> 7";
  1538.                 } else {
  1539.                     return null;
  1540.                 }
  1541.             },
  1542.             getFeatureRoadType: function (feature, layer) {
  1543.                 if (layer.getFeatureRoadType) {
  1544.                     return layer.getFeatureRoadType(feature);
  1545.                 } else {
  1546.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  1547.                 }
  1548.             }
  1549.         },
  1550.         WV: {
  1551.             baseUrl: 'https://gis.transportation.wv.gov/arcgis/rest/services/Routes/MapServer/',
  1552.             defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1553.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1554.             fcMapLayers: [
  1555.                 { layerID: 1, fcPropName: 'F_System', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_System', 'RouteID'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } }
  1556.             ],
  1557.             information: { Source: 'WV DOT' },
  1558.             isPermitted: function () { return true; },
  1559.             getWhereClause: function (context) {
  1560.                 if (context.mapContext.zoom < 4) {
  1561.                     return context.layer.fcPropName + ' NOT IN (9,19)';
  1562.                 } else {
  1563.                     return null;
  1564.                 }
  1565.             },
  1566.             getFeatureRoadType: function (feature, layer) {
  1567.                 if (layer.getFeatureRoadType) {
  1568.                     return layer.getFeatureRoadType(feature);
  1569.                 } else {
  1570.                     var fcCode = feature.attributes[layer.fcPropName];
  1571.                     var fc = fcCode;
  1572.                     if (fcCode === 11) fc = 1;
  1573.                     else if (fcCode === 4 || fcCode === 12) fc = 2;
  1574.                     else if (fcCode === 2 || fcCode === 14) fc = 3;
  1575.                     else if (fcCode === 6 || fcCode === 16) fc = 4;
  1576.                     else if (fcCode === 7 || fcCode === 17 || fcCode === 8 || fcCode === 18) fc = 5;
  1577.                     else fc = 7;
  1578.                     var id = feature.attributes.RouteID;
  1579.                     var prefix = id.substr(2, 1);
  1580.                     var isInterstate = false;
  1581.                     var isUS = false;
  1582.                     var isState = false;
  1583.                     switch (prefix) {
  1584.                         case '1':
  1585.                             isInterstate = true;
  1586.                             break;
  1587.                         case '2':
  1588.                             isUS = true;
  1589.                             break;
  1590.                         case '3':
  1591.                             isState = true;
  1592.                             break;
  1593.                     }
  1594.                     if (fc > 1 && isInterstate) { fc = 1; }
  1595.                     else if (fc > 3 && isUS) { fc = 3; }
  1596.                     else if (fc > 4 && isState) { fc = 4; }
  1597.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1598.                 }
  1599.             }
  1600.         },
  1601.         WY: {
  1602.             baseUrl: 'https://gisservices.wyoroad.info/arcgis/rest/services/ITSM/LAYERS/MapServer/',
  1603.             defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1604.             zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1605.             fcMapLayers: [
  1606.                 {
  1607.                     layerID: 20, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1608.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1609.                 },
  1610.                 {
  1611.                     layerID: 21, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1612.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1613.                 },
  1614.                 {
  1615.                     layerID: 22, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1616.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1617.                 },
  1618.                 {
  1619.                     layerID: 23, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1620.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1621.                 },
  1622.                 {
  1623.                     layerID: 24, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1624.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1625.                 },
  1626.                 {
  1627.                     layerID: 25, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1628.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1629.                 },
  1630.                 {
  1631.                     layerID: 26, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1632.                     roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1633.                 }
  1634.             ],
  1635.             information: { Source: 'WYDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Minimum suggested FC.' },
  1636.             getWhereClause: function (context) {
  1637.                 if (context.mapContext.zoom < 4) {
  1638.                     return context.layer.fcPropName + " <> 'Local'";
  1639.                 } else {
  1640.                     return null;
  1641.                 }
  1642.             },
  1643.             getFeatureRoadType: function (feature, layer) {
  1644.                 var attr = feature.attributes;
  1645.                 var fc = attr[layer.fcPropName];
  1646.                 var route = attr.COMMON_ROUTE_NAME;
  1647.                 switch (fc) {
  1648.                     case 'Interstate': fc = 1; break;
  1649.                     case 'Expressway': fc = 2; break;
  1650.                     case 'Principal Arterial': fc = 3; break;
  1651.                     case 'Minor Arterial': fc = 4; break;
  1652.                     case 'Major Collector': fc = 5; break
  1653.                     case 'Minor Collector': fc = 6; break;
  1654.                     default: fc = 7;
  1655.                 }
  1656.                 var isIntBiz = /I (25|80) BUS/.test(route);
  1657.                 var isUS = /US \d+/.test(route);
  1658.                 var isUSBiz = /US \d+ BUS/.test(route);
  1659.                 var isState = /WY \d+/.test(route);
  1660.                 var isStateBiz = /WY \d+ BUS/.test(route);
  1661.                 if (fc > 3 && (isUS || isIntBiz)) {
  1662.                     fc = isUSBiz ? 4 : 3;
  1663.                 } else if (fc > 4 && isState) {
  1664.                     fc = isStateBiz ? 5 : 4;
  1665.                 }
  1666.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1667.             }
  1668.         }
  1669.     };
  1670.  
  1671.     function log(message, level) {
  1672.         if (message && (!level || (level <= _debugLevel))) {
  1673.             console.log('FC Layer: ', message);
  1674.         }
  1675.     }
  1676.  
  1677.     function dynamicSort(property) {
  1678.         var sortOrder = 1;
  1679.         if (property[0] === "-") {
  1680.             sortOrder = -1;
  1681.             property = property.substr(1);
  1682.         }
  1683.         return function (a, b) {
  1684.             var props = property.split('.');
  1685.             props.forEach(function (prop) {
  1686.                 a = a[prop];
  1687.                 b = b[prop];
  1688.             });
  1689.             var result = (a < b) ? -1 : (a > b) ? 1 : 0;
  1690.             return result * sortOrder;
  1691.         };
  1692.     }
  1693.  
  1694.     function dynamicSortMultiple() {
  1695.         /*
  1696.      * save the arguments object as it will be overwritten
  1697.      * note that arguments object is an array-like object
  1698.      * consisting of the names of the properties to sort by
  1699.      */
  1700.         var props = arguments;
  1701.         if (arguments[0] && Array.isArray(arguments[0])) {
  1702.             props = arguments[0];
  1703.         }
  1704.         return function (obj1, obj2) {
  1705.             var i = 0, result = 0, numberOfProperties = props.length;
  1706.             /* try getting a different result from 0 (equal)
  1707.          * as long as we have extra properties to compare
  1708.          */
  1709.             while (result === 0 && i < numberOfProperties) {
  1710.                 result = dynamicSort(props[i])(obj1, obj2);
  1711.                 i++;
  1712.             }
  1713.             return result;
  1714.         };
  1715.     }
  1716.  
  1717.     function generateUUID() {
  1718.         var d = new Date().getTime();
  1719.         var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
  1720.             var r = (d + Math.random() * 16) % 16 | 0;
  1721.             d = Math.floor(d / 16);
  1722.             return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
  1723.         });
  1724.         return uuid;
  1725.     }
  1726.  
  1727.     function loadSettingsFromStorage() {
  1728.         var loadedSettings = $.parseJSON(localStorage.getItem(_settingsStoreName));
  1729.         var defaultSettings = {
  1730.             lastVersion: null,
  1731.             layerVisible: true,
  1732.             activeStateAbbr: 'ALL',
  1733.             hideStreet: false
  1734.         };
  1735.         _settings = loadedSettings ? loadedSettings : defaultSettings;
  1736.         for (var prop in defaultSettings) {
  1737.             if (!_settings.hasOwnProperty(prop)) {
  1738.                 _settings[prop] = defaultSettings[prop];
  1739.             }
  1740.         }
  1741.     }
  1742.  
  1743.     function saveSettingsToStorage() {
  1744.         if (localStorage) {
  1745.             _settings.lastVersion = _scriptVersion;
  1746.             _settings.layerVisible = _mapLayer.visibility;
  1747.             localStorage.setItem(_settingsStoreName, JSON.stringify(_settings));
  1748.             log('Settings saved', 1);
  1749.         }
  1750.     }
  1751.  
  1752.     function getLineWidth() {
  1753.         return 12 * Math.pow(1.15, (W.map.getZoom() - 1));
  1754.     }
  1755.  
  1756.     function sortArray(array) {
  1757.         array.sort(function (a, b) { if (a < b) return -1; if (a > b) return 1; else return 0; });
  1758.     }
  1759.  
  1760.     function getVisibleStateAbbrs() {
  1761.         var visibleStates = [];
  1762.         W.model.states.getObjectArray().forEach(function (state) {
  1763.             var stateAbbr = _statesHash[state.name];
  1764.             var activeStateAbbr = _settings.activeStateAbbr;
  1765.             if (_stateSettings[stateAbbr] && _stateSettings.global.isPermitted(stateAbbr) && (!activeStateAbbr || activeStateAbbr === 'ALL' || activeStateAbbr === stateAbbr)) {
  1766.                 visibleStates.push(stateAbbr);
  1767.             }
  1768.         });
  1769.         return visibleStates;
  1770.     }
  1771.  
  1772.     function getAsync(url, context) {
  1773.         return new Promise(function (resolve, reject) {
  1774.             GM_xmlhttpRequest({
  1775.                 context: context, method: "GET", url: url,
  1776.                 onload: function (res) {
  1777.                     if (res.status.toString() === '200') {
  1778.                         resolve({ responseText: res.responseText, context: context });
  1779.                     } else {
  1780.                         reject({ responseText: res.responseText, context: context });
  1781.                     }
  1782.                 },
  1783.                 onerror: function () {
  1784.                     reject(Error("Network Error"));
  1785.                 }
  1786.             });
  1787.         });
  1788.     }
  1789.     function wait(ms) {
  1790.         var start = new Date().getTime();
  1791.         var end = start;
  1792.         while (end < start + ms) {
  1793.             end = new Date().getTime();
  1794.         }
  1795.     }
  1796.     function getUrl(context, queryType, queryParams) {
  1797.         var extent = context.mapContext.extent,
  1798.             zoom = context.mapContext.zoom,
  1799.             layer = context.layer,
  1800.             state = context.state;
  1801.  
  1802.         var whereParts = [];
  1803.         var geometry = { xmin: extent.left, ymin: extent.bottom, xmax: extent.right, ymax: extent.top, spatialReference: { wkid: 102100, latestWkid: 3857 } };
  1804.         var geometryStr = JSON.stringify(geometry);
  1805.         var stateWhereClause = state.getWhereClause(context);
  1806.         var layerPath = layer.layerPath || '';
  1807.         var url = state.baseUrl + layerPath + layer.layerID + '/query?geometry=' + encodeURIComponent(geometryStr);
  1808.  
  1809.         if (queryType === 'countOnly') {
  1810.             url += '&returnCountOnly=true';
  1811.         } else if (queryType === 'idsOnly') {
  1812.             url += '&returnIdsOnly=true';
  1813.         } else if (queryType === 'paged') {
  1814.             // TODO
  1815.         } else {
  1816.             url += '&returnGeometry=true&maxAllowableOffset=' + state.zoomSettings.maxOffset[zoom];
  1817.             url += '&outFields=' + encodeURIComponent(layer.outFields.join(','));
  1818.             if (queryType === 'idRange') {
  1819.                 var idPropName = context.layer.idPropName;
  1820.                 whereParts.push('(' + queryParams.idFieldName + '>=' + queryParams.range[0] + ' AND ' + queryParams.idFieldName + '<=' + queryParams.range[1] + ')');
  1821.             }
  1822.         }
  1823.         if (stateWhereClause) whereParts.push(stateWhereClause);
  1824.         if (whereParts.length > 0) url += '&where=' + encodeURIComponent(whereParts.join(' AND '));
  1825.         url += '&spatialRel=esriSpatialRelIntersects&geometryType=esriGeometryEnvelope&inSR=102100&outSR=3857&f=json';
  1826.         //wait(500);  // I don't know why this was in the code.  Leaving it commented here just in case it was a hack to solve some issue.
  1827.         return url;
  1828.     }
  1829.  
  1830.     function convertFcToRoadTypeVectors(feature, state, stateAbbr, layer, zoom) {
  1831.         var roadType = state.getFeatureRoadType(feature, layer);
  1832.         log(feature, 3);
  1833.         var zIndex = _stateSettings.global.roadTypes.indexOf(roadType) * 100;
  1834.         var vectors = [];
  1835.         var lineFeatures = [];
  1836.         var attr = {
  1837.             //fcFeatureUniqueId: stateAbbr + '-' + layer.layerID + '-' + feature.attributes[layer.idPropName],
  1838.             //fcFeatureId: feature.attributes[layer.idPropName],
  1839.             state: stateAbbr,
  1840.             layerID: layer.layerID,
  1841.             roadType: roadType,
  1842.             dotAttributes: $.extend({}, feature.attributes),
  1843.             color: state.defaultColors[roadType],
  1844.             strokeWidth: getLineWidth,
  1845.             zIndex: zIndex
  1846.         };
  1847.  
  1848.         feature.geometry.paths.forEach(function (path) {
  1849.             var pointList = [];
  1850.             var newPoint = null;
  1851.             var lastPoint = null;
  1852.             path.forEach(function (point) {
  1853.                 pointList.push(new OpenLayers.Geometry.Point(point[0], point[1]));
  1854.             });
  1855.             var vectorFeature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString(pointList), attr);
  1856.             vectors.push(vectorFeature);
  1857.         });
  1858.  
  1859.         return vectors;
  1860.     }
  1861.  
  1862.     function fetchLayerFC(context) {
  1863.         var url = getUrl(context, 'idsOnly');
  1864.         log(url, 2);
  1865.         if (!context.parentContext.cancel) {
  1866.             return getAsync(url, context).bind(context).then(function (res) {
  1867.                 var ids = $.parseJSON(res.responseText);
  1868.                 if (!ids.objectIds) ids.objectIds = [];
  1869.                 sortArray(ids.objectIds);
  1870.                 log(ids, 2);
  1871.                 return ids;
  1872.             }).then(function (res) {
  1873.                 var context = this;
  1874.                 var idRanges = [];
  1875.                 if (res.objectIds) {
  1876.                     var len = res.objectIds ? res.objectIds.length : 0;
  1877.                     var currentIndex = 0;
  1878.                     var offset = Math.min(this.layer.maxRecordCount, 1000);
  1879.                     while (currentIndex < len) {
  1880.                         var nextIndex = currentIndex + offset;
  1881.                         if (nextIndex >= len) nextIndex = len - 1;
  1882.                         idRanges.push({ range: [res.objectIds[currentIndex], res.objectIds[nextIndex]], idFieldName: res.objectIdFieldName });
  1883.                         currentIndex = nextIndex + 1;
  1884.                     }
  1885.                     log(context.layer.layerID, 2);
  1886.                     log(idRanges, 2);
  1887.                 }
  1888.                 return idRanges;
  1889.             }).map(function (idRange) {
  1890.                 var context = this;
  1891.                 if (!context.parentContext.cancel) {
  1892.                     var url = getUrl(this, 'idRange', idRange);
  1893.                     log(url, 2);
  1894.                     return getAsync(url, context).then(function (res) {
  1895.                         var context = res.context;
  1896.                         if (!context.parentContext.cancel) {
  1897.                             var features = $.parseJSON(res.responseText).features;
  1898.                             // if (context.parentContext.callCount === 0 ) {
  1899.                             //     _mapLayer.removeAllFeatures();
  1900.                             // }
  1901.                             context.parentContext.callCount++;
  1902.                             log('Feature Count=' + (features ? features.length : 0), 2);
  1903.                             features = features ? features : [];
  1904.                             var vectors = [];
  1905.                             features.forEach(function (feature) {
  1906.                                 if (!res.context.parentContext.cancel) {
  1907.                                     var vector = convertFcToRoadTypeVectors(feature, context.state, context.stateAbbr, context.layer, context.mapContext.zoom);
  1908.                                     //var fcFeatureUniqueId = vector[0].attributes.fcFeatureUniqueId;
  1909.                                     //context.parentContext.addedFcFeatureUniqueIds.push(fcFeatureUniqueId);
  1910.                                     if (/*!context.parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId] &&*/ !(vector[0].attributes.roadType === 'St' && _settings.hideStreet)) {
  1911.                                         vectors.push(vector);
  1912.                                     }
  1913.                                 }
  1914.                             });
  1915.                             return vectors;
  1916.                         }
  1917.                     });
  1918.                 } else {
  1919.                     log('Async call cancelled', 1);
  1920.                 }
  1921.             });
  1922.         }
  1923.     }
  1924.  
  1925.     function fetchStateFC(context) {
  1926.         var state = _stateSettings[context.stateAbbr];
  1927.         var contexts = [];
  1928.         state.fcMapLayers.forEach(function (layer) {
  1929.             contexts.push({ parentContext: context.parentContext, layer: layer, state: state, stateAbbr: context.stateAbbr, mapContext: context.mapContext });
  1930.         });
  1931.         return Promise.map(contexts, function (context) {
  1932.             return fetchLayerFC(context);
  1933.         });
  1934.     }
  1935.  
  1936.     var _lastPromise = null;
  1937.     var _lastContext = null;
  1938.     var _fcCallCount = 0;
  1939.     function fetchAllFC() {
  1940.         if (!_mapLayer.visibility) return;
  1941.  
  1942.         if (_lastPromise) { _lastPromise.cancel(); }
  1943.         $('#fc-loading-indicator').text('Loading FC...');
  1944.  
  1945.         var mapContext = { zoom: W.map.getZoom(), extent: W.map.getExtent() };
  1946.         var contexts = [];
  1947.         var parentContext = { callCount: 0,/*existingFcFeatureUniqueIds:{}, addedFcFeatureUniqueIds:[],*/ startTime: Date.now() };
  1948.         // _mapLayer.features.forEach(function(vectorFeature) {
  1949.         //     var fcFeatureUniqueId = vectorFeature.attributes.fcFeatureUniqueId;
  1950.         //     var existingFcFeatureUniqueIdArray = parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId];
  1951.         //     if (!existingFcFeatureUniqueIdArray) {
  1952.         //         existingFcFeatureUniqueIdArray = [];
  1953.         //         parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId] = existingFcFeatureUniqueIdArray;
  1954.         //     }
  1955.         //     existingFcFeatureUniqueIdArray.push(vectorFeature);
  1956.         // });
  1957.         if (_lastContext) _lastContext.cancel = true;
  1958.         _lastContext = parentContext;
  1959.         getVisibleStateAbbrs().forEach(function (stateAbbr) {
  1960.             contexts.push({ parentContext: parentContext, stateAbbr: stateAbbr, mapContext: mapContext });
  1961.         });
  1962.         var map = Promise.map(contexts, function (context) {
  1963.             return fetchStateFC(context);
  1964.         }).bind(parentContext).then(function (statesVectorArrays) {
  1965.             if (!this.cancel) {
  1966.                 _mapLayer.removeAllFeatures();
  1967.                 statesVectorArrays.forEach(function (vectorsArray) {
  1968.                     vectorsArray.forEach(function (vectors) {
  1969.                         vectors.forEach(function (vector) {
  1970.                             vector.forEach(function (vectorFeature) {
  1971.                                 _mapLayer.addFeatures(vectorFeature);
  1972.                             });
  1973.                         });
  1974.                     });
  1975.                 });
  1976.                 //buildTable();
  1977.                 // for(var fcFeatureUniqueId in this.existingFcFeatureUniqueIds) {
  1978.                 //     if(this.addedFcFeatureUniqueIds.indexOf(fcFeatureUniqueId) === -1) {
  1979.                 //         if (!this.cancel) _mapLayer.removeFeatures(this.existingFcFeatureUniqueIds[fcFeatureUniqueId]);
  1980.                 //     }
  1981.                 // }
  1982.                 log('TOTAL RETRIEVAL TIME = ' + (Date.now() - parentContext.startTime), 1);
  1983.                 log(statesVectorArrays, 1);
  1984.             }
  1985.             return statesVectorArrays;
  1986.         }).catch(function (e) {
  1987.             $('#fc-loading-indicator').text('FC Error! (check console for details)');
  1988.             log(e, 0);
  1989.         }).finally(function () {
  1990.             _fcCallCount -= 1;
  1991.             if (_fcCallCount === 0) {
  1992.                 $('#fc-loading-indicator').text('');
  1993.             }
  1994.         });
  1995.  
  1996.         _fcCallCount += 1;
  1997.         _lastPromise = map;
  1998.     }
  1999.  
  2000.     function onLayerCheckboxChanged(checked) {
  2001.         _mapLayer.setVisibility(checked);
  2002.     }
  2003.  
  2004.     function onLayerVisibilityChanged(evt) {
  2005.         _settings.layerVisible = _mapLayer.visibility;
  2006.         saveSettingsToStorage();
  2007.         if (_mapLayer.visibility) {
  2008.             fetchAllFC();
  2009.         }
  2010.     }
  2011.  
  2012.     function showScriptInfoAlert() {
  2013.         /* Check version and alert on update */
  2014.         if (_alertUpdate && _scriptVersion !== _settings.lastVersion) {
  2015.             alert(_scriptVersionChanges);
  2016.         }
  2017.     }
  2018.  
  2019.     function initLayer() {
  2020.         var _drawingContext = {
  2021.             getZIndex: function (feature) {
  2022.                 return feature.attributes.zIndex;
  2023.             },
  2024.             getStrokeWidth: function () { return getLineWidth(); }
  2025.         };
  2026.         var defaultStyle = new OpenLayers.Style({
  2027.             strokeColor: '${color}', //'#00aaff',
  2028.             strokeDashstyle: "solid",
  2029.             strokeOpacity: 1.0,
  2030.             strokeWidth: '${strokeWidth}',
  2031.             graphicZIndex: '${zIndex}'
  2032.         });
  2033.  
  2034.         var selectStyle = new OpenLayers.Style({
  2035.             //strokeOpacity: 1.0,
  2036.             strokeColor: '#000000'
  2037.         });
  2038.  
  2039.         _mapLayer = new OpenLayers.Layer.Vector("FC Layer", {
  2040.             uniqueName: "__FCLayer",
  2041.             displayInLayerSwitcher: false,
  2042.             rendererOptions: { zIndexing: true },
  2043.             styleMap: new OpenLayers.StyleMap({
  2044.                 'default': defaultStyle,
  2045.                 'select': selectStyle
  2046.             })
  2047.         });
  2048.  
  2049.         _mapLayer.setOpacity(0.5);
  2050.  
  2051.         I18n.translations[I18n.locale].layers.name.__FCLayer = "FC Layer";
  2052.  
  2053.         _mapLayer.displayInLayerSwitcher = true;
  2054.         _mapLayer.events.register('visibilitychanged', null, onLayerVisibilityChanged);
  2055.         _mapLayer.setVisibility(_settings.layerVisible);
  2056.  
  2057.         W.map.addLayer(_mapLayer);
  2058.         _mapLayer.setZIndex(_mapLayerZIndex);
  2059.         WazeWrap.Interface.AddLayerCheckbox('Display', 'FC Layer', _settings.layerVisible, onLayerCheckboxChanged);
  2060.         // Hack to fix layer zIndex.  Some other code is changing it sometimes but I have not been able to figure out why.
  2061.         // It may be that the FC layer is added to the map before some Waze code loads the base layers and forces other layers higher. (?)
  2062.  
  2063.         var checkLayerZIndex = function () {
  2064.             if (_mapLayer.getZIndex() != _mapLayerZIndex) {
  2065.                 log("ADJUSTED FC LAYER Z-INDEX " + _mapLayerZIndex + ', ' + _mapLayer.getZIndex(), 1);
  2066.                 _mapLayer.setZIndex(_mapLayerZIndex);
  2067.             }
  2068.         };
  2069.  
  2070.         setInterval(function () { checkLayerZIndex(); }, 200);
  2071.  
  2072.         W.map.events.register("moveend", W.map, function (e) {
  2073.             fetchAllFC();
  2074.             return true;
  2075.         }, true);
  2076.     }
  2077.  
  2078.     function initUserPanel() {
  2079.         var $tab = $('<li>').append($('<a>', { 'data-toggle': 'tab', href: '#sidepanel-fc-layer' }).text('FC'));
  2080.         var $panel = $('<div>', { class: 'tab-pane', id: 'sidepanel-fc-layer' });
  2081.         var $stateSelect = $('<select>', { id: 'fcl-state-select', class: 'form-control disabled', style: 'disabled' }).append($('<option>', { value: 'ALL' }).text('All'));
  2082.         // $stateSelect.change(function(evt) {
  2083.         //     _settings.activeStateAbbr = evt.target.value;
  2084.         //     saveSettingsToStorage();
  2085.         //     _mapLayer.removeAllFeatures();
  2086.         //     fetchAllFC();
  2087.         // });
  2088.         for (var stateAbbr in _stateSettings) {
  2089.             if (stateAbbr !== 'global') {
  2090.                 $stateSelect.append($('<option>', { value: stateAbbr }).text(reverseStatesHash(stateAbbr)));
  2091.             }
  2092.         }
  2093.  
  2094.         var $hideStreet = $('<div>', { id: 'fcl-hide-street-container', class: 'controls-container' })
  2095.             .append($('<input>', { type: 'checkbox', name: 'fcl-hide-street', id: 'fcl-hide-street' }).prop('checked', _settings.hideStreet).click(function () {
  2096.                 _settings.hideStreet = $(this).is(':checked');
  2097.                 saveSettingsToStorage();
  2098.                 _mapLayer.removeAllFeatures();
  2099.                 fetchAllFC();
  2100.             }))
  2101.             .append($('<label>', { for: 'fcl-hide-street' }).text('Hide local street highlights'));
  2102.  
  2103.         $stateSelect.val(_settings.activeStateAbbr ? _settings.activeStateAbbr : 'ALL');
  2104.  
  2105.         $panel.append(
  2106.             $('<div>', { class: 'form-group' }).append(
  2107.                 $('<label>', { class: 'control-label' }).text('Select a state')
  2108.             ).append(
  2109.                 $('<div>', { class: 'controls', id: 'fcl-state-select-container' }).append(
  2110.                     $('<div>').append($stateSelect)
  2111.                 )
  2112.             ),
  2113.             $hideStreet,
  2114.             $('<div>', { id: 'fcl-table-container' })
  2115.         );
  2116.  
  2117.         $panel.append($('<div>', { id: 'fcl-state-info' }));
  2118.  
  2119.         $panel.append(
  2120.             $('<div>', { style: 'margin-top:10px;font-size:10px;color:#999999;' })
  2121.                 .append($('<div>').text('version ' + _scriptVersion))
  2122.                 .append(
  2123.                     $('<div>').append(
  2124.                         $('<a>', { href: '#' /*, target:'__blank'*/ }).text('Discussion Forum (currently n/a)')
  2125.                     )
  2126.                 )
  2127.         );
  2128.  
  2129.         $('#user-tabs > .nav-tabs').append($tab);
  2130.         $('#user-info > .flex-parent > .tab-content').append($panel);
  2131.         $('#fcl-state-select').change(function () {
  2132.             _settings.activeStateAbbr = this.value;
  2133.             saveSettingsToStorage();
  2134.             loadStateFCInfo();
  2135.             fetchAllFC();
  2136.         });
  2137.         loadStateFCInfo();
  2138.     }
  2139.  
  2140.     function loadStateFCInfo() {
  2141.         $('#fcl-state-info').empty();
  2142.         if (_stateSettings[_settings.activeStateAbbr]) {
  2143.             var stateInfo = _stateSettings[_settings.activeStateAbbr].information;
  2144.             var $panelStateInfo = $('<dl>');
  2145.             for (var propertyName in stateInfo) {
  2146.                 $panelStateInfo.append($('<dt>', { style: 'margin-top:1em;color:#777777' }).text(propertyName))
  2147.                     .append($('<dd>').text(stateInfo[propertyName]))
  2148.             }
  2149.             $('#fcl-state-info').append($panelStateInfo);
  2150.         }
  2151.     }
  2152.  
  2153.     function addLoadingIndicator() {
  2154.         $('.loading-indicator').after($('<div class="loading-indicator" style="margin-right:10px" id="fc-loading-indicator">'));
  2155.     }
  2156.  
  2157.     function initGui() {
  2158.         addLoadingIndicator();
  2159.         initLayer();
  2160.         initUserPanel();
  2161.         showScriptInfoAlert();
  2162.     }
  2163.  
  2164.     function processText(text) {
  2165.         return new Promise(function (resolve, reject) {
  2166.             var newText = text.replace(/(e)/, 'E');
  2167.             resolve(newText);
  2168.         });
  2169.     }
  2170.  
  2171.     function init() {
  2172.         if (_debugLevel > 0 && Promise.config) {
  2173.             Promise.config({
  2174.                 warnings: true,
  2175.                 longStackTraces: true,
  2176.                 cancellation: true,
  2177.                 monitoring: false
  2178.             });
  2179.         } else {
  2180.             Promise.config({
  2181.                 warnings: false,
  2182.                 longStackTraces: false,
  2183.                 cancellation: true,
  2184.                 monitoring: false
  2185.             });
  2186.         }
  2187.  
  2188.         var u = W.loginManager.user;
  2189.         _uid = u.id;
  2190.         _r = u.rank + 1;
  2191.         _isAM = u.isAreaManager;
  2192.         loadSettingsFromStorage();
  2193.         String.prototype.replaceAll = function (search, replacement) {
  2194.             var target = this;
  2195.             return target.replace(new RegExp(search, 'g'), replacement);
  2196.         };
  2197.         initGui();
  2198.         W.prefs.on("change:isImperial", function () { initUserPanel(); loadSettingsFromStorage(); });
  2199.         fetchAllFC();
  2200.         log('Initialized.', 0);
  2201.     }
  2202.  
  2203.     function bootstrap() {
  2204.         if (W && W.loginManager &&
  2205.             W.loginManager.events &&
  2206.             W.loginManager.events.register &&
  2207.             W.model && W.model.states && W.model.states.getObjectArray().length &&
  2208.             W.map && W.loginManager.user &&
  2209.             WazeWrap.Ready) {
  2210.             log('Initializing...', 0);
  2211.  
  2212.             init();
  2213.         } else {
  2214.             log('Bootstrap failed. Trying again...', 0);
  2215.             unsafeWindow.setTimeout(function () {
  2216.                 bootstrap();
  2217.             }, 1000);
  2218.         }
  2219.     }
  2220.  
  2221.     log('Bootstrap...', 0);
  2222.     bootstrap();
  2223. })();