/*

* Copyright (C) 2014-2015 Stichting Mapcode Foundation (http://www.mapcode.com)

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

var entity_iso = [

'VAT','MCO','GIB','TKL','CCK','BLM','NRU','TUV','MAC','SXM',

'MAF','NFK','PCN','BVT','BMU','IOT','SMR','GGY','AIA','MSR',

'JEY','CXR','WLF','VGB','LIE','ABW','MHL','ASM','COK','SPM',

'NIU','KNA','CYM','BES','MDV','SHN','MLT','GRD','VIR','MYT',

'SJM','VCT','HMD','BRB','ATG','CUW','SYC','PLW','MNP','AND',

'GUM','IMN','LCA','FSM','SGP','TON','DMA','BHR','KIR','TCA',

'STP','HKG','MTQ','FRO','GLP','COM','MUS','REU','LUX','WSM',

'SGS','PYF','CPV','TTO','BRN','ATF','PRI','CYP','LBN','JAM',

'GMB','QAT','FLK','VUT','MNE','BHS','TLS','SWZ','KWT','FJI',

'NCL','SVN','ISR','PSE','SLV','BLZ','DJI','MKD','RWA','HTI',

'BDI','GNQ','ALB','SLB','ARM','LSO','BEL','MDA','GNB','TWN',

'BTN','CHE','NLD','DNK','EST','DOM','SVK','CRI','BIH','HRV',

'TGO','LVA','LTU','LKA','GEO','IRL','SLE','PAN','CZE','GUF',

'ARE','AUT','AZE','SRB','JOR','PRT','HUN','KOR','ISL','GTM',

'CUB','BGR','LBR','HND','BEN','ERI','MWI','PRK','NIC','GRC',

'TJK','BGD','NPL','TUN','SUR','URY','KHM','SYR','SEN','KGZ',

'BLR','GUY','LAO','ROU','GHA','UGA','GBR','GIN','ECU','ESH',

'GAB','NZL','BFA','PHL','ITA','OMN','POL','CIV','NOR','MYS',

'VNM','FIN','COG','DEU','JPN','ZWE','PRY','IRQ','MAR','UZB',

'SWE','PNG','CMR','TKM','ESP','THA','YEM','FRA','ALA','KEN',

'BWA','MDG','UKR','SSD','CAF','SOM','AFG','MMR','ZMB','CHL',

'TUR','PAK','MOZ','NAM','VEN','NGA','TZA','EGY','MRT','BOL',

'ETH','COL','ZAF','MLI','AGO','NER','TCD','PER','MNG','IRN',

'LBY','SDN','IDN','DIF','TLA','MOR','AGU','5CL','QUE','HID',

'5MX','TAB','NAY','GUA','PUE','YUC','ROO','SIN','CAM','MIC',

'SLP','GRO','NLE','BCN','VER','CHP','BCS','ZAC','JAL','TAM',

'OAX','DUR','COA','SON','CHH','GRL','SAU','COD','DZA','KAZ',

'ARG','2DD','2DN','2CH','2AN','2LD','2DL','2ML','2NL','2MN',

'2TR','2MZ','2SK','2PB','2HR','2AR','2AS','2BR','2UT','2GA',

'2KL','2TN','2HP','2JK','2CT','2JH','2KA','2RJ','2OR','2GJ',

'2WB','2MP','2TG','2AP','2MH','2UP','2PY','NSW','ACT','JBT',

'4NT','4SA','TAS','VIC','4WA','QLD','6DF','6SE','6AL','6RJ',

'6ES','6RN','6PB','6SC','6PE','6AP','6CE','6AC','6PR','6RR',

'6RO','6SP','6PI','6TO','6RS','6MA','6GO','6MS','6BA','6MG',

'6MT','6PA','6AM','1DC','1RI','1DE','1CT','1NJ','1NH','1VT',

'1MA','1HI','1MD','1WV','1SC','1ME','1IN','1KY','1TN','1VA',

'1OH','1PA','1MS','1LA','1AL','1AR','1NC','1NY','1IA','1IL',

'1GA','1WI','1FL','1MO','1OK','1ND','1WA','1SD','1NE','1KS',

'1ID','1UT','1MN','1MI','1WY','1OR','1CO','1NV','1AZ','1NM',

'1MT','1CA','1TX','1AK','3BC','3AB','3ON','3QC','3SK','3MB',

'3NL','3NB','3NS','3PE','3YT','3NT','3NU','IND','AUS','BRA',

'USA','MEX','MOW','SPE','KGD','7IN','7AD','7SE','7KB','7KC',

'7CE','7CU','IVA','LIP','ORL','TUL','7BE','VLA','KRS','KLU',

'7TT','BRY','YAR','RYA','AST','MOS','SMO','7DA','VOR','NGR',

'PSK','KOS','STA','KDA','7KL','TVE','LEN','ROS','VGG','VLG',

'MUR','7KR','NEN','7KO','ARK','7MO','NIZ','PNZ','7KI','7ME',

'ORE','ULY','7PM','7BA','7UD','7TA','SAM','SAR','YAN','7KM',

'SVE','TYU','KGN','7CH','7BU','ZAB','IRK','NVS','TOM','OMS',

'7KK','KEM','7AL','ALT','7TY','KYA','MAG','CHU','KAM','SAK',

'7PO','YEV','KHA','AMU','7SA','CAN','RUS','8SH','8TJ','8BJ',

'8HI','8NX','8CQ','8ZJ','8JS','8FJ','8AH','8LN','8SD','8SX',

'8JX','8HA','8GZ','8GD','8HB','8JL','8HE','8SN','8NM','8HL',

'8HN','8GX','8SC','8YN','8XZ','8GS','8QH','8XJ','CHN','UMI',

'CPT','ATA','AAA', '?'];

var aliases = "2UK=2UT,2CG=2CT,1GU=GUM,1UM=UMI,1VI=VIR,1AS=ASM,1MP=MNP,4CX=CXR,4CC=CCK,4NF=NFK,4HM=HMD,COL=5CL,5ME=5MX,MEX=5MX,5AG=AGU,5BC=BCN,5BS=BCS,5CM=CAM,5CS=CHP,5CH=CHH,5CO=COA,5DF=DIF,5DG=DUR,5GT=GUA,5GR=GRO,5HG=HID,5JA=JAL,5MI=MIC,5MO=MOR,5NA=NAY,5NL=NLE,5OA=OAX,5PB=PUE,5QE=QUE,5QR=ROO,5SL=SLP,5SI=SIN,5SO=SON,5TB=TAB,5TL=TLA,5VE=VER,5YU=YUC,5ZA=ZAC,811=8BJ,812=8TJ,813=8HE,814=8SX,815=8NM,821=8LN,822=8JL,823=8HL,831=8SH,832=8JS,833=8ZJ,834=8AH,835=8FJ,836=8JX,837=8SD,841=8HA,842=8HB,843=8HN,844=8GD,845=8GX,846=8HI,850=8CQ,851=8SC,852=8GZ,853=8YN,854=8XZ,861=8SN,862=8GS,863=8QH,864=8NX,865=8XJ,871=TWN,891=HKG,892=MAC,8TW=TWN,8HK=HKG,8MC=MAC,BEL=7BE,KIR=7KI,PRI=7PO,CHE=7CH,KHM=7KM,PER=7PM,TAM=7TT,0US=USA,0AU=AUS,0RU=RUS,0CN=CHN,TAA=SHN,ASC=SHN,DGA=IOT,WAK=MHL,JTN=UMI,MID=1HI,1PR=PRI,5TM=TAM,TAM=TAM,2OD=2OR,";

var dependency = [

27, 410, 50, 410, 26, 410, 53, 410, 48, 410, 47, 410, 76, 410, 529, 410, 38, 410,

21, 408, 4, 408, 42, 408, 11, 408,

18, 166, 14, 166, 15, 166, 23, 166, 32, 166, 82, 166, 2, 166, 17, 166, 51, 166, 20, 166, 19, 166, 12, 166, 35, 166, 70, 166, 59, 166,

61, 528, 8, 528, 109, 528,

63, 113, 265, 113,

198, 181,

530, 197, 129, 197, 71, 197, 75, 197, 64, 197, 62, 197, 90, 197, 67, 197, 10, 197, 29, 197, 5, 197, 22, 197,

13, 178, 40, 178,

25, 112, 33, 112, 45, 112, 9, 112,

28, 171, 30, 171, 3, 171,

77, 210,

-1];

var usa_from = 343;

var usa_upto = 393;

var ccode_usa = 410;

var ind_from = 271;

var ind_upto = 306;

var ccode_ind = 407;

var can_from = 394;

var can_upto = 406;

var ccode_can = 495;

var aus_from = 307;

var aus_upto = 315;

var ccode_aus = 408;

var mex_from = 233;

var mex_upto = 264;

var ccode_mex = 411;

var bra_from = 316;

var bra_upto = 342;

var ccode_bra = 409;

var chn_from = 497;

var chn_upto = 527;

var ccode_chn = 528;

var rus_from = 412;

var rus_upto = 494;

var ccode_rus = 496;

var ccode_earth = 532;

var parents3 = "USA,IND,CAN,AUS,MEX,BRA,RUS,CHN,";

var parents2 = "US,IN,CA,AU,MX,BR,RU,CN,";

var ccode_start = 112; // NLD

var mapcode_cversion = "2.0.2";

var mapcode_dataversion = "2.2";

// *************************** mapcode_org *********************

var mapcode_javaversion = '2.2/Data'+mapcode_dataversion;

/// PRIVATE returns string without leading spaces and plus-signs, and trailing spaces

function trim(str) {

return str.replace(/^\s+|\s+$/g, '');

}

/// PRIVATE return 2-letter parent country abbreviation (disam in range 1..8)

function parentname2(disam) {

return parents2.substr(disam * 3 - 3, 2);

}

/// PRIVATE given a parent country abbreviation, return disam (in range 1-8) or negative if error

function parentletter(territoryAlphaCode) {

var p = -1;

var srch = String(territoryAlphaCode).toUpperCase() + ',';

var len = srch.length;

if (len == 3) {

p = parents2.indexOf(srch);

} else if (len == 4) {

p = parents3.indexOf(srch);

}

if (p < 0) {

return -2;

}

return 1 + (p / len);

}

/// PRIVATE given an ISO abbreviation, set disambiguation for future calls to iso2ccode(); returns nonzero in case of error

var disambiguate = 1; // GLOBAL

function set_disambiguate(territoryAlphaCode) {

var p = parentletter(territoryAlphaCode);

if (p < 0) {

return -2;

}

disambiguate = p;

return 0;

}

/// PRIVATE returns alias of ISO abbreviation (if any), or return empty

function alias2iso(territoryAlphaCode) {

var rx;

if (territoryAlphaCode.length == 2) {

rx = '[0-9]' + territoryAlphaCode;

} else {

rx = territoryAlphaCode;

}

rx = new RegExp(rx + '=', '');

var p = aliases.search(rx);

if (p >= 0) {

return aliases.substring(p + 4, p + 7);

}

return '';

}

/// PRIVATE given ISO code, return territoryNumber (or negative if error)

function iso2ccode(territoryAlphaCode) {

if (typeof territoryAlphaCode == "undefined") {

return undefined;

}

if (!isNaN(territoryAlphaCode) && territoryAlphaCode < 800) {

return territoryAlphaCode;

}

territoryAlphaCode = trim(String(territoryAlphaCode)).toUpperCase();

var sep = territoryAlphaCode.lastIndexOf('-');

if (sep < 0) {

sep = territoryAlphaCode.lastIndexOf(' ');

}

if (sep >= 0) {

var prefix = territoryAlphaCode.substring(0, sep);

territoryAlphaCode = trim(territoryAlphaCode.substring(sep + 1));

if (territoryAlphaCode.length != 2 && territoryAlphaCode.length != 3) {

return -1;

}

if (set_disambiguate(prefix)) {

return -2;

}

// FIRST see if the territoryAlphaCode is in this disambiguation

if (territoryAlphaCode.length == 2) {

return iso2ccode(disambiguate + '' + territoryAlphaCode);

}

else if (territoryAlphaCode.length == 3) {

var isoa = alias2iso(territoryAlphaCode);

if (isoa) {

if (isoa.charAt(0) == disambiguate) {

territoryAlphaCode = isoa;

}

}

}

}

if (territoryAlphaCode.length != 2 && territoryAlphaCode.length != 3) {

return -1;

}

{

var testiso = (territoryAlphaCode.length == 2 ? disambiguate + '' + territoryAlphaCode : territoryAlphaCode);

var i;

for (i = 0; i < entity_iso.length; i++) {

if (testiso == entity_iso[i]) {

return i;

}

}

// 1.31 improvement: recognise alias in current context

if (territoryAlphaCode.length == 2 && testiso.length == 3) {

var aliasiso = alias2iso(testiso);

if (aliasiso) {

return iso2ccode(aliasiso);

}

}

// look for any iso2 match

if (territoryAlphaCode.length == 2) {

for (i = 0; i < entity_iso.length; i++) {

if (entity_iso[i].charCodeAt(0) <= 57 && territoryAlphaCode == entity_iso[i].substring(1, 3)) {

return i;

}

}

}

territoryAlphaCode = alias2iso(territoryAlphaCode);

if (territoryAlphaCode) {

return iso2ccode(territoryAlphaCode);

}

}

return -1;

}

/// PUBLIC given an alphacode (such as US-AL), returns the territory number (or negative).

/// A contextTerritoryNumber helps to interpret ambiguous (abbreviated) AlphaCodes, such as "AL"

function getTerritoryNumber(territoryAlphaCode, contextTerritoryNumber) {

if (contextTerritoryNumber) {

set_disambiguate(entity_iso[contextTerritoryNumber]);

}

return iso2ccode(territoryAlphaCode);

}

/// PUBLIC return full name of territory

function getTerritoryFullname(territory) {

var territoryNumber = getTerritoryNumber(territory);

if (territoryNumber == undefined || territoryNumber < 0 || territoryNumber > ccode_earth) {

return undefined;

}

var idx = isofullname[territoryNumber].indexOf(' (');

if (idx > 0) {

return isofullname[territoryNumber].substr(0, idx);

}

return isofullname[territoryNumber];

}

/// PUBLIC return parent country of subdivision (negative if territory is not a subdivision)

function getParentOf(territory) {

var territoryNumber = getTerritoryNumber(territory);

if (territoryNumber >= usa_from && territoryNumber <= usa_upto) {

return ccode_usa;

}

if (territoryNumber >= ind_from && territoryNumber <= ind_upto) {

return ccode_ind;

}

if (territoryNumber >= can_from && territoryNumber <= can_upto) {

return ccode_can;

}

if (territoryNumber >= aus_from && territoryNumber <= aus_upto) {

return ccode_aus;

}

if (territoryNumber >= mex_from && territoryNumber <= mex_upto) {

return ccode_mex;

}

if (territoryNumber >= bra_from && territoryNumber <= bra_upto) {

return ccode_bra;

}

if (territoryNumber >= rus_from && territoryNumber <= rus_upto) {

return ccode_rus;

}

if (territoryNumber >= chn_from && territoryNumber <= chn_upto) {

return ccode_chn;

}

return -199;

}

/// PUBLIC returns true iff territoryNumber is a state

function isSubdivision(territory) {

return getParentOf(territory) >= 0;

}

/// PUBLIC returns true iff territoryNumber is a country that has states

function hasSubdivision(territory) {

return (parents3.indexOf(getTerritoryAlphaCode(getTerritoryNumber(territory), 0)) >= 0);

}

/// PRIVATE returns true iff x in range (all values in millionths)

function isInRangeX(x, minx, maxx) {

if (minx <= x && x < maxx) {

return true;

}

if (x < minx) {

x += 360000000;

} else {

x -= 360000000;

}

if (minx <= x && x < maxx) {

return true;

}

return false;

}

/// PRIVATE returns true iff coordinate inside rectangle (all values in millionths)

function fitsInside(coord, mm) {

return ( mm.miny <= coord.y && coord.y < mm.maxy && isInRangeX(coord.x, mm.minx, mm.maxx) );

}

/// PRIVATE returns true iff coordinate inside rectangle with some room to spare outside (all values in millionths)

function fitsInsideWithRoom(coord, mm) {

if ((( mm.miny - 60) > coord.y) || (coord.y >= (mm.maxy + 60))) {

return false;

}

var xroom = xDivider4(mm.miny, mm.maxy) / 4;

return isInRangeX(coord.x, mm.minx - xroom, mm.maxx + xroom);

}

/// PRIVATE returns true iff coordinate inside rectangle with some room to spare inside (all values in millionths)

function fitsWellInside(coord, mm) {

if ((( mm.miny + 60) > coord.y) || (coord.y >= (mm.maxy - 60))) {

return false;

}

var xroom = xDivider4(mm.miny, mm.maxy) / 4;

return isInRangeX(coord.x, mm.minx + xroom, mm.maxx - xroom);

}

/// PRIVATE returns true iff coordinate near the rectangle border

function isNearBorderOf(coord, mm) {

return fitsInsideWithRoom(coord, mm) && (!fitsWellInside(coord, mm));

}

/// PUBLIC return the AlphaCode (usually an ISO 3166 code) of a territory

/// format: 0=local (often ambiguous), 1=international (full and unambiguous, DEFAULT), 2=shortest (shortest non-ambiguous abbreviation)

function getTerritoryAlphaCode(territory, format) {

if (format == undefined) {

format = 1;

}

var territoryNumber = getTerritoryNumber(territory);

if (territoryNumber < 0 || territoryNumber > ccode_earth) {

return -1;

}

var n = entity_iso[territoryNumber];

if (/^[0-9]/.test(n)) {

n = n.substring(1);

}

if (format) {

var parent = getParentOf(territoryNumber);

if (parent >= 0) {

if (format == 2) {

// see if n occurs multiple times, if not, don't bother with parent

var count = 0;

var i = aliases.indexOf(n + '=');

if (i >= 0) {

count = 2;

} else if (n.length == 2) {

for (i = 0; i < entity_iso.length; i++) {

if (entity_iso[i].substr(1) == n) {

if (entity_iso[i].charAt(0) >= '0') {

if (entity_iso[i].charAt(0) <= '9') {

count++;

if (count > 1) {

break;

}

}

}

}

}

} else {

for (i = 0; i < entity_iso.length; i++) {

if (entity_iso[i] == n) {

count++;

if (count > 1) {

break;

}

}

}

}

if (count == 1) {

return n;

}

}

return parentname2(parentletter(entity_iso[parent])) + '-' + n;

}

}

return n;

}

/// PRIVATE low-level routines for data access

function dataFirstRecord(territoryNumber) {

return data_start[territoryNumber];

}

function dataLastRecord(territoryNumber) {

return data_start[++territoryNumber] - 1;

}

function minmaxSetup(i) {

var d = data_maxy[i];

if (d < 10) {

var shortmaxy = [0, 122309, 27539, 27449, 149759, 2681190, 60119, 62099, 491040, 86489];

d = shortmaxy[d];

}

return {

minx: data_minx[i],

miny: data_miny[i],

maxx: data_minx[i] + data_maxx[i],

maxy: data_miny[i] + d

};

}

/// low-level tables for mapcode encoding and decoding

var xdivider19 = [

360, 360, 360, 360, 360, 360, 361, 361, 361, 361, // 5.2429 degrees

362, 362, 362, 363, 363, 363, 364, 364, 365, 366, // 10.4858 degrees

366, 367, 367, 368, 369, 370, 370, 371, 372, 373, // 15.7286 degrees

374, 375, 376, 377, 378, 379, 380, 382, 383, 384, // 20.9715 degrees

386, 387, 388, 390, 391, 393, 394, 396, 398, 399, // 26.2144 degrees

401, 403, 405, 407, 409, 411, 413, 415, 417, 420, // 31.4573 degrees

422, 424, 427, 429, 432, 435, 437, 440, 443, 446, // 36.7002 degrees

449, 452, 455, 459, 462, 465, 469, 473, 476, 480, // 41.9430 degrees

484, 488, 492, 496, 501, 505, 510, 515, 520, 525, // 47.1859 degrees

530, 535, 540, 546, 552, 558, 564, 570, 577, 583, // 52.4288 degrees

590, 598, 605, 612, 620, 628, 637, 645, 654, 664, // 57.6717 degrees

673, 683, 693, 704, 715, 726, 738, 751, 763, 777, // 62.9146 degrees

791, 805, 820, 836, 852, 869, 887, 906, 925, 946, // 68.1574 degrees

968, 990, 1014, 1039, 1066, 1094, 1123, 1154, 1187, 1223, // 73.4003 degrees

1260, 1300, 1343, 1389, 1438, 1490, 1547, 1609, 1676, 1749, // 78.6432 degrees

1828, 1916, 2012, 2118, 2237, 2370, 2521, 2691, 2887, 3114, // 83.8861 degrees

3380, 3696, 4077, 4547, 5139, 5910, 6952, 8443, 10747, 14784, // 89.1290 degrees

23681, 59485];

var nc = [1, 31, 961, 29791, 923521, 28629151, 887503681];

var xside = [0, 5, 31, 168, 961, 168 * 31, 29791, 165869, 923521, 5141947, 28629151];

var yside = [0, 6, 31, 176, 961, 176 * 31, 29791, 165869, 923521, 5141947, 28629151];

var decodeChar = [

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,

-1, -2, 10, 11, 12, -3, 13, 14, 15, 1, 16, 17, 18, 19, 20, 0,

21, 22, 23, 24, 25, -4, 26, 27, 28, 29, 30, -1, -1, -1, -1, -1,

-1, -2, 10, 11, 12, -3, 13, 14, 15, 1, 16, 17, 18, 19, 20, 0,

21, 22, 23, 24, 25, -4, 26, 27, 28, 29, 30, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1];

var encodeChar = [

'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M',

'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z',

'A', 'E', 'U'];

/// PRIVATE given a minimum and maximum latitude, returns a relative stretch factor (in 360th) for the longitude

function xDivider4(miny, maxy) {

if (miny >= 0) {

return xdivider19[(miny) >> 19];

}

if (maxy >= 0) {

return xdivider19[0];

}

return xdivider19[(-maxy) >> 19];

}

/// PRIVATE lowest level encode/decode routines

function decodeBase31(str) {

var value = 0;

var i;

for (i = 0; i < str.length; i++) {

var c = str.charCodeAt(i);

if (c == 46) // dot!

{

return value;

}

if (decodeChar[c] < 0) {

return NaN;

}

value = value * 31 + decodeChar[c];

}

return value;

}

function decodeTriple(input) {

var triplex, tripley;

var c1 = decodeChar[input.charCodeAt(0)];

var x = decodeBase31(input.substr(1));

if (c1 < 24) {

triplex = (c1 % 6) * 28 + Math.floor(x / 34);

tripley = Math.floor(c1 / 6) * 34 + Math.floor(x % 34);

}

else {

tripley = (x % 40) + 136;

triplex = Math.floor(x / 40) + 24 * (c1 - 24);

}

return {y: tripley, x: triplex}

}

function decodeSixWide(v, width, height) {

var D = 6;

var col = Math.floor(v / (height * 6));

var maxcol = Math.floor((width - 4) / 6);

if (col >= maxcol) {

col = maxcol;

D = width - maxcol * 6;

}

var w = v - (col * height * 6 );

var x6 = col * 6 + (w % D);

var y6 = height - 1 - Math.floor(w / D);

return {y: y6, x: x6}

}

function encodeSixWide(x, y, width, height) {

var D = 6;

var col = Math.floor(x / 6);

var maxcol = Math.floor((width - 4) / 6);

if (col >= maxcol) {

col = maxcol;

D = width - maxcol * 6;

}

return (height * 6 * col) + (height - 1 - y) * D + (x - col * 6);

}

var getDebugInfo; // caller must set this to 1 to get debug info about first successful encode

var mcInfo;

/*

type: 1=topdown nameless, 2=sixwide nameless, 3=regulargrid 4=irregular grid 5=rounded groups 6=unrounded groups

record: rectangle record used to encode

rectangles:

rectEncompassing : encompassing rectangle of country or subdivision

rectArea : area of the encoding record

rectSubarea : subArea (as determined by prefix)

rectZone : subArea zone (only exists for huge regular grids, e.g. Antarctica)

rectRegion : region in Subarea

rectCell : cell for the mapcode (usually 10x10 meters)

rectCell1 : precision 1 cell (usually 2x2 meters)

rectCell2 : precision 2 cell (usually 33x33 cm)

other debug information:

form = alphanumeric description of mapcode form

dotPosition = position to insert dot in mapcode

prefixDivx,prefixDivy = how prefix divides the area (if any)

*/

function asDegreeRect(minx, miny, dx, dy) {

return {minx: minx / 1000000, miny: miny / 1000000, maxx: (minx + dx) / 1000000, maxy: (miny + dy) / 1000000};

}

/// high-precision extension routines

function maxMapcodePrecision() {

return 8;

}

function encodeExtension(result, enc, extrax4, extray, dividerx4, dividery, extraDigits, ydirection) {

if (!extraDigits) {

return result;

}

if (extraDigits > maxMapcodePrecision()) {

extraDigits = maxMapcodePrecision();

}

// the following are all perfect integers

var factorx = 810000 * dividerx4; // 810000 = 30^4

var factory = 810000 * dividery;

var valx = (810000 * extrax4) + (enc.fraclon);

var valy = (810000 * extray ) + (enc.fraclat * ydirection);

// protect against floating point errors

if (valx < 0) { valx=0; } else if (valx >= factorx) { valx=factorx-1; }

if (valy < 0) { valy=0; } else if (valy >= factory) { valy=factory-1; }

result += '-';

for(;;) {

factorx /= 30;

var gx = Math.floor(valx / factorx);

factory /= 30;

var gy = Math.floor(valy / factory);

var column1 = Math.floor(gx / 6);

var row1 = Math.floor(gy / 5);

result += encodeChar[row1 * 5 + column1];

if (--extraDigits == 0) { break; }

var column2 = (gx % 6);

var row2 = (gy % 5);

result += encodeChar[row2 * 6 + column2];

if (--extraDigits == 0) { break; }

valx -= factorx * gx;

valy -= factory * gy;

}

return result;

}

// ***** MapcodeZone *****

// cconstruct and return empty MapcodeZone

function mzEmpty() {

return {fminx: 0, fmaxx: 0, fminy: 0, fmaxy: 0};

}

// construct and return copy of MapcodeZone

function mzCopy(zone) {

return {

fminx: zone.fminx,

fmaxx: zone.fmaxx,

fminy: zone.fminy,

fmaxy: zone.fmaxy };

}

// return true iff MapcodeZone is empty

function mzIsEmpty(zone) {

return ((zone.fmaxx <= zone.fminx) || (zone.fmaxy <= zone.fminy));

}

// comstruct MapcodeZone based on coordinate and deltas (in Fractions)

function mzSetFromFractions(y, x, yDelta, xDelta) {

if (yDelta < 0) {

return {

fminx: x,

fmaxx: x + xDelta,

fminy: y + 1 + yDelta, // y+yDelta can NOT be represented

fmaxy: y + 1 }; // y CAN be represented

}

else {

return {

fminx: x,

fmaxx: x + xDelta,

fminy: y,

fmaxy: y + yDelta };

}

}

function mzMidPointFractions(zone) {

return {

y: Math.floor((zone.fminy + zone.fmaxy) / 2),

x: Math.floor((zone.fminx + zone.fmaxx) / 2) };

}

function convertFractionsToCoord32(p) {

p.y = Math.floor(p.y / 810000);

p.x = Math.floor(p.x / 3240000);

return p;

}

function wrap(p) {

if (p.x >= (180 * 3240000 * 1000000))

p.x -= (360 * 3240000 * 1000000);

if (p.x < (-180 * 3240000 * 1000000))

p.x += (360 * 3240000 * 1000000);

return p;

}

function convertFractionsToDegrees(p) {

p.y /= ( 810000 * 1000000);

p.x /= (3240000 * 1000000);

return p;

}

function mzRestrictZoneTo(zone, mm) {

var z = mzCopy(zone);

var miny = mm.miny * 810000;

if (z.fminy < miny) {

z.fminy = miny;

}

var maxy = mm.maxy * 810000;

if (z.fmaxy > maxy) {

z.fmaxy = maxy;

}

if (z.fminy < z.fmaxy) {

var minx = mm.minx * 3240000;

var maxx = mm.maxx * 3240000;

if ((maxx < 0) && (z.fminx > 0)) {

minx += (360000000 * 3240000);

maxx += (360000000 * 3240000);

}

else if ((minx > 1) && (z.fmaxx < 0)) {

minx -= (360000000 * 3240000);

maxx -= (360000000 * 3240000);

}

if (z.fminx < minx) {

z.fminx = minx;

}

if (z.fmaxx > maxx) {

z.fmaxx = maxx;

}

}

return z;

}

// returns (possibly empty) MapcodeZone

function decodeExtension(extensionchars, y, x, dividerx4, dividery, lon_offset4, extremeLatMicroDeg, maxLonMicroDeg) {

var processor = 1;

var lon32 = 0;

var lat32 = 0;

var odd = 0;

var idx = 0;

if (extensionchars.length > 8) {

return mzEmpty(); // too many digits

}

while (idx < extensionchars.length) {

var column1, row1, column2, row2;

var c1 = decodeChar[extensionchars.charCodeAt(idx++)];

if (c1 < 0 || c1 == 30) {

return mzEmpty();

}

row1 = Math.floor(c1 / 5);

column1 = (c1 % 5);

if (idx < extensionchars.length) {

var c2 = decodeChar[extensionchars.charCodeAt(idx++)];

if (c2 < 0 || c2 == 30) {

return mzEmpty();

}

row2 = Math.floor(c2 / 6);

column2 = (c2 % 6);

} else { //

row2 = 0;

odd = 1;

column2 = 0;

} //

processor *= 30;

lon32 = lon32 * 30 + column1 * 6 + column2;

lat32 = lat32 * 30 + row1 * 5 + row2;

} //

while (processor < 810000.0) {

dividerx4 *= 30;

dividery *= 30;

processor *= 30;

}

var lon4 = (x * 3240000.0) + (lon32 * dividerx4) + (lon_offset4 * 810000.0);

var lat1 = (y * 810000.0) + (lat32 * dividery );

// determine the range of coordinates that are encode to this mapcode

var mapcodeZone;

if (odd) { // odd

mapcodeZone = mzSetFromFractions(lat1, lon4, 5 * dividery, 6 * dividerx4);

} else { // not odd

mapcodeZone = mzSetFromFractions(lat1, lon4, dividery, dividerx4);

} // not odd

// FORCE_RECODE - restrict the coordinate range to the extremes that were provided

if (mapcodeZone.fmaxx > (maxLonMicroDeg * 3240000.0)) {

mapcodeZone.fmaxx = (maxLonMicroDeg * 3240000.0);

}

if (dividery >= 0 ) {

if (mapcodeZone.fmaxy > (extremeLatMicroDeg * 810000.0)) {

mapcodeZone.fmaxy = (extremeLatMicroDeg * 810000.0);

}

} else {

if (mapcodeZone.fminy < (extremeLatMicroDeg * 810000.0)) {

mapcodeZone.fminy = (extremeLatMicroDeg * 810000.0);

}

}

return mapcodeZone;

}

function decodeGrid(input, extensionchars, headerletter, m)

{

var relx, rely;

var prefixlength = input.indexOf('.');

var postfixlength = input.length - 1 - prefixlength;

if (prefixlength == 1 && postfixlength == 4) {

prefixlength++;

postfixlength--;

input = input.charAt(0) + input.charAt(2) + '.' + input.substring(3);

}

divy = smartdiv(m);

if (divy == 1) {

divx = xside[prefixlength];

divy = yside[prefixlength];

} else {

divx = Math.floor(nc[prefixlength] / divy);

}

if (prefixlength == 4 && divx == 961 && divy == 961) {

input = input.charAt(0) + input.charAt(2) + input.charAt(1) + input.substr(3);

}

var v = decodeBase31(input);

if (divx != divy && prefixlength > 2) // D==6

{

var d = decodeSixWide(v, divx, divy);

relx = d.x;

rely = d.y;

}

else {

relx = Math.floor(v / divy);

rely = v % divy;

rely = divy - 1 - rely;

}

var mm = minmaxSetup(m);

var ygridsize = Math.floor((mm.maxy - mm.miny + divy - 1) / divy);

var xgridsize = Math.floor((mm.maxx - mm.minx + divx - 1) / divx);

rely = mm.miny + (rely * ygridsize);

relx = mm.minx + (relx * xgridsize);

var xp = xside[postfixlength];

var dividerx = Math.floor((xgridsize + xp - 1) / xp);

var yp = yside[postfixlength];

var dividery = Math.floor((ygridsize + yp - 1) / yp);

var rest = input.substr(prefixlength + 1);

// decoderelative (postfix vs rely,relx)

var difx;

var dify;

if (postfixlength == 3) {

var d = decodeTriple(rest);

difx = d.x;

dify = d.y;

}

else {

if (postfixlength == 4) {

rest = rest.charAt(0) + rest.charAt(2) + rest.charAt(1) + rest.charAt(3);

}

v = decodeBase31(rest);

difx = Math.floor(v / yp);

dify = Math.floor(v % yp);

}

dify = yp - 1 - dify;

var cornery = rely + (dify * dividery);

var cornerx = relx + (difx * dividerx);

if (!fitsInside({y:cornery,x:cornerx},mm)) {

return mzEmpty();

} // even corner does not fit!

var decodeMaxx = ((relx + xgridsize) < mm.maxx) ? (relx + xgridsize) : mm.maxx;

var decodeMaxy = ((rely + ygridsize) < mm.maxy) ? (rely + ygridsize) : mm.maxy;

return decodeExtension(extensionchars, cornery, cornerx, dividerx << 2, dividery,

0, decodeMaxy, decodeMaxx); // grid

}

function encodeBase31(value, nrchars) {

var result = '';

while (nrchars-- > 0) {

result = encodeChar[value % 31] + result;

value = Math.floor(value / 31);

}

return result;

}

function encodeTriple(difx, dify, dividerx, dividery) {

if (dify < 4 * 34) {

var rx = Math.floor(difx / 28);

var ry = Math.floor(dify / 34);

var cx = (difx % 28);

var cy = (dify % 34);

if (getDebugInfo) {

mcInfo.rectRegion = asDegreeRect((1000000 * mcInfo.rectSubarea.minx) + ((28 * rx * dividerx)), (1000000 * (mcInfo.rectSubarea.maxy)) - (((34 * ry) + 34) * dividery), 28 * dividerx, 34 * dividery);

}

return encodeChar[(rx + 6 * ry)] + encodeBase31(cx * 34 + cy, 2);

}

else {

var rx = Math.floor(difx / 24);

var cx = (difx % 24);

if (getDebugInfo) {

mcInfo.rectRegion = asDegreeRect((1000000 * mcInfo.rectSubarea.minx) + (24 * rx * dividerx), 1000000 * mcInfo.rectSubarea.miny, 24 * dividerx, 40 * dividery);

}

return encodeChar[rx + 24] + encodeBase31(cx * 40 + (dify - 136), 2);

}

}

function encodeGrid(enc, m, mm, headerletter, extraDigits) {

var orgcodex = Codex(m);

var codex = orgcodex;

if (codex == 21) {

codex = 22;

}

if (codex == 14) {

codex = 23;

}

var prefixlength = Math.floor(codex / 10);

var postfixlength = (codex % 10);

divy = smartdiv(m);

if (divy == 1) {

divx = xside[prefixlength];

divy = yside[prefixlength];

if (getDebugInfo) {

mcInfo = {type: 3, record: m, regular: true, form: (prefixlength == 2 ? 'rr' : 'rrrr')};

}

}

else {

divx = Math.floor(nc[prefixlength] / divy);

if (getDebugInfo) {

mcInfo = {

type: 4,

record: m,

regular: false,

form: (prefixlength == 2 ? 'ss' : prefixlength == 3 ? 'sss' : 'ssss')

};

}

}

if (getDebugInfo) {

mcInfo.dotPosition = (headerletter ? prefixlength + 1 : prefixlength);

if (headerletter) {

mcInfo.form = 'h' + mcInfo.form;

}

mcInfo.headerletter = headerletter;

mcInfo.prefixDivx = divx;

mcInfo.prefixDivy = divy;

}

var ygridsize = Math.floor((mm.maxy - mm.miny + divy - 1) / divy);

var rely = enc.coord32.y - mm.miny;

rely = Math.floor(rely / ygridsize);

var xgridsize = Math.floor((mm.maxx - mm.minx + divx - 1) / divx);

var x = enc.coord32.x;

var relx = x - mm.minx;

if (relx < 0) {

x += 360000000;

relx += 360000000;

} else if (relx >= 360000000) {

x -= 360000000;

relx -= 360000000;

} // 1.32 fix FIJI edge case

if (relx < 0) {

return NaN;

}

relx = Math.floor(relx / xgridsize);

if (relx >= divx) {

return NaN;

}

var v;

if (divx != divy && prefixlength > 2) // D==6

{

v = encodeSixWide(relx, rely, divx, divy);

}

else {

v = relx * divy + (divy - 1 - rely);

}

result = encodeBase31(v, prefixlength);

if (prefixlength == 4 && divx == 961 && divy == 961) {

result = result.charAt(0) + result.charAt(2) + result.charAt(1) + result.charAt(3);

}

if (getDebugInfo && prefixlength == 4 && divx == 961 && divy == 961) {

mcInfo.rectZone = asDegreeRect(mm.minx + 31 * xgridsize * Math.floor(relx / 31), mm.miny + 31 * ygridsize * Math.floor(rely / 31), xgridsize * 31, ygridsize * 31);

}

rely = mm.miny + (rely * ygridsize);

relx = mm.minx + (relx * xgridsize);

var dividery = Math.floor((((ygridsize)) + yside[postfixlength] - 1) / yside[postfixlength]);

var dividerx = Math.floor((((xgridsize)) + xside[postfixlength] - 1) / xside[postfixlength]);

result += '.';

// encoderelative