parser.js

// Copyright (c) 2018, Gordon Lam
"use strict";

(function(){
  var root;
  root = this;
  var XRegExp;

  if (typeof require !== "undefined"){
     XRegExp = require('xregexp/src/xregexp.js');
  }
  else
    XRegExp = root.XRegExp;

  var parser = {};
  var MatchedAddress = {};

  var Street_Type = {
    'ACCESS': 'ACCESS',
    'ALLEY': 'ALLEY',
    'ALLEYWAY': 'ALLEYWAY',
    'AMBLE': 'AMBLE',
    'ANCHORAGE': 'ANCHORAGE',
    'APPROACH': 'APPROACH',
    'ARCADE': 'ARCADE',
    'ARTERY': 'ARTERY',
    'AVENUE': 'AVENUE',
    'BASIN': 'BASIN',
    'BEACH': 'BEACH',
    'BEND': 'BEND',
    'BLOCK': 'BLOCK',
    'BOULEVARD': 'BOULEVARD',
    'BRACE': 'BRACE',
    'BRAE': 'BRAE',
    'BREAK': 'BREAK',
    'BRIDGE': 'BRIDGE',
    'BROADWAY': 'BROADWAY',
    'BROW': 'BROW',
    'BYPASS': 'BYPASS',
    'BYWAY': 'BYWAY',
    'CAUSEWAY': 'CAUSEWAY',
    'CENTRE': 'CENTRE',
    'CENTREWAY': 'CENTREWAY',
    'CHASE': 'CHASE',
    'CIRCLE': 'CIRCLE',
    'CIRCLET': 'CIRCLET',
    'CIRCUIT': 'CIRCUIT',
    'CIRCUS': 'CIRCUS',
    'CLOSE': 'CLOSE',
    'COLONNADE': 'COLONNADE',
    'COMMON': 'COMMON',
    'CONCOURSE': 'CONCOURSE',
    'COPSE': 'COPSE',
    'CORNER': 'CORNER',
    'CORSO': 'CORSO',
    'COURT': 'COURT',
    'COURTYARD': 'COURTYARD',
    'COVE': 'COVE',
    'CRESCENT': 'CRESCENT',
    'CREST': 'CREST',
    'CROSS': 'CROSS',
    'CROSSING': 'CROSSING',
    'CROSSROAD': 'CROSSROAD',
    'CROSSWAY': 'CROSSWAY',
    'CRUISEWAY': 'CRUISEWAY',
    'CUL-DE-SAC': 'CUL-DE-SAC',
    'CUTTING': 'CUTTING',
    'DALE': 'DALE',
    'DELL': 'DELL',
    'DEVIATION': 'DEVIATION',
    'DIP': 'DIP',
    'DISTRIBUTOR': 'DISTRIBUTOR',
    'DRIVE': 'DRIVE',
    'DRIVEWAY': 'DRIVEWAY',
    'EDGE': 'EDGE',
    'ELBOW': 'ELBOW',
    'END': 'END',
    'ENTRANCE': 'ENTRANCE',
    'ESPLANADE': 'ESPLANADE',
    'ESTATE': 'ESTATE',
    'EXPRESSWAY': 'EXPRESSWAY',
    'EXTENSION': 'EXTENSION',
    'FAIRWAY': 'FAIRWAY',
    'FIRE TRACK': 'FIRE TRACK',
    'FIRETRAIL': 'FIRETRAIL',
    'FLAT': 'FLAT',
    'FOLLOW': 'FOLLOW',
    'FOOTWAY': 'FOOTWAY',
    'FORESHORE': 'FORESHORE',
    'FORMATION': 'FORMATION',
    'FREEWAY': 'FREEWAY',
    'FRONT': 'FRONT',
    'FRONTAGE': 'FRONTAGE',
    'GAP': 'GAP',
    'GARDEN': 'GARDEN',
    'GATE': 'GATE',
    'GARDENS': 'GARDENS',
    'GATES': 'GATES',
    'GLADE': 'GLADE',
    'GLEN': 'GLEN',
    'GRANGE': 'GRANGE',
    'GREEN': 'GREEN',
    'GROUND': 'GROUND',
    'GROVE': 'GROVE',
    'GULLY': 'GULLY',
    'HEIGHTS': 'HEIGHTS',
    'HIGHROAD': 'HIGHROAD',
    'HIGHWAY': 'HIGHWAY',
    'HILL': 'HILL',
    'INTERCHANGE': 'INTERCHANGE',
    'INTERSECTION': 'INTERSECTION',
    'JUNCTION': 'JUNCTION',
    'KEY': 'KEY',
    'LANDING': 'LANDING',
    'LANE': 'LANE',
    'LANEWAY': 'LANEWAY',
    'LEES': 'LEES',
    'LINE': 'LINE',
    'LINK': 'LINK',
    'LITTLE': 'LITTLE',
    'LOOKOUT': 'LOOKOUT',
    'LOOP': 'LOOP',
    'LOWER': 'LOWER',
    'MALL': 'MALL',
    'MEANDER': 'MEANDER',
    'MEW': 'MEW',
    'MEWS': 'MEWS',
    'MOTORWAY': 'MOTORWAY',
    'MOUNT': 'MOUNT',
    'NOOK': 'NOOK',
    'OUTLOOK': 'OUTLOOK',
    'PARADE': 'PARADE',
    'PARK': 'PARK',
    'PARKLANDS': 'PARKLANDS',
    'PARKWAY': 'PARKWAY',
    'PART': 'PART',
    'PASS': 'PASS',
    'PATH': 'PATH',
    'PATHWAY': 'PATHWAY',
    'PIAZZA': 'PIAZZA',
    'PLACE': 'PLACE',
    'PLATEAU': 'PLATEAU',
    'PLAZA': 'PLAZA',
    'POCKET': 'POCKET',
    'POINT': 'POINT',
    'PORT': 'PORT',
    'PROMENADE': 'PROMENADE',
    'QUAD': 'QUAD',
    'QUADRANGLE': 'QUADRANGLE',
    'QUADRANT': 'QUADRANT',
    'QUAY': 'QUAY',
    'QUAYS': 'QUAYS',
    'RAMBLE': 'RAMBLE',
    'RAMP': 'RAMP',
    'RANGE': 'RANGE',
    'REACH': 'REACH',
    'RESERVE': 'RESERVE',
    'REST': 'REST',
    'RETREAT': 'RETREAT',
    'RIDE': 'RIDE',
    'RIDGE': 'RIDGE',
    'RIDGEWAY': 'RIDGEWAY',
    'RIGHT OF WAY': 'RIGHT OF WAY',
    'RING': 'RING',
    'RISE': 'RISE',
    'RIVER': 'RIVER',
    'RIVERWAY': 'RIVERWAY',
    'RIVIERA': 'RIVIERA',
    'ROAD': 'ROAD',
    'ROADS': 'ROADS',
    'ROADSIDE': 'ROADSIDE',
    'ROADWAY': 'ROADWAY',
    'RONDE': 'RONDE',
    'ROSEBOWL': 'ROSEBOWL',
    'ROTARY': 'ROTARY',
    'ROUND': 'ROUND',
    'ROUTE': 'ROUTE',
    'ROW': 'ROW',
    'RUE': 'RUE',
    'RUN': 'RUN',
    'SERVICE WAY': 'SERVICE WAY',
    'SIDING': 'SIDING',
    'SLOPE': 'SLOPE',
    'SOUND': 'SOUND',
    'SPUR': 'SPUR',
    'SQUARE': 'SQUARE',
    'STAIRS': 'STAIRS',
    'STATE HIGHWAY': 'STATE HIGHWAY',
    'STEPS': 'STEPS',
    'STRAND': 'STRAND',
    'STREET': 'STREET',
    'STRIP': 'STRIP',
    'SUBWAY': 'SUBWAY',
    'TARN': 'TARN',
    'TERRACE': 'TERRACE',
    'THOROUGHFARE': 'THOROUGHFARE',
    'TOLLWAY': 'TOLLWAY',
    'TOP': 'TOP',
    'TOR': 'TOR',
    'TOWERS': 'TOWERS',
    'TRACK': 'TRACK',
    'TRAIL': 'TRAIL',
    'TRAILER': 'TRAILER',
    'TRIANGLE': 'TRIANGLE',
    'TRUNKWAY': 'TRUNKWAY',
    'TURN': 'TURN',
    'UNDERPASS': 'UNDERPASS',
    'UPPER': 'UPPER',
    'VALE': 'VALE',
    'VIADUCT': 'VIADUCT',
    'VIEW': 'VIEW',
    'VILLAS': 'VILLAS',
    'VISTA': 'VISTA',
    'WADE': 'WADE',
    'WALK': 'WALK',
    'WALKWAY': 'WALKWAY',
    'WAY': 'WAY',
    'WHARF': 'WHARF',
    'WYND': 'WYND',
    'YARD': 'YARD',
    'ACCS':'ACCS',
    'ALLY':'ALLY',
    'ALWY':'ALWY',
    'AMBL':'AMBL',
    'ANCG':'ANCG',
    'APP':'APP',
    'ARC':'ARC',
    'ART':'ART',
    'AVE':'AVE',
    'BASN':'BASN',
    'BCH':'BCH',
    'BDGE':'BDGE',
    'BDWY':'BDWY',
    'BEND':'BEND',
    'BLK':'BLK',
    'BRAE':'BRAE',
    'BRCE':'BRCE',
    'BRK':'BRK',
    'BROW':'BROW',
    'BVD':'BVD',
    'BYPA':'BYPA',
    'BYWY':'BYWY',
    'CAUS':'CAUS',
    'CCT':'CCT',
    'CDS':'CDS',
    'CH':'CH',
    'CIR':'CIR',
    'CL':'CL',
    'CLDE':'CLDE',
    'CLT':'CLT',
    'CMMN':'CMMN',
    'CNR':'CNR',
    'CNWY':'CNWY',
    'CON':'CON',
    'COVE':'COVE',
    'COWY':'COWY',
    'CPS':'CPS',
    'CRCS':'CRCS',
    'CRD':'CRD',
    'CRES':'CRES',
    'CRSG':'CRSG',
    'CRSS':'CRSS',
    'CRST':'CRST',
    'CSO':'CSO',
    'CT':'CT',
    'CTR':'CTR',
    'CTTG':'CTTG',
    'CTYD':'CTYD',
    'CUWY':'CUWY',
    'DALE':'DALE',
    'DELL':'DELL',
    'DEVN':'DEVN',
    'DIP':'DIP',
    'DR':'DR',
    'DRWY':'DRWY',
    'DSTR':'DSTR',
    'EDGE':'EDGE',
    'ELB':'ELB',
    'END':'END',
    'ENT':'ENT',
    'ESP':'ESP',
    'EST':'EST',
    'EXP':'EXP',
    'EXTN':'EXTN',
    'FAWY':'FAWY',
    'FITR':'FITR',
    'FLAT':'FLAT',
    'FOLW':'FOLW',
    'FORM':'FORM',
    'FRNT':'FRNT',
    'FRTG':'FRTG',
    'FSHR':'FSHR',
    'FTRK':'FTRK',
    'FTWY':'FTWY',
    'FWY':'FWY',
    'GAP':'GAP',
    'GDN':'GDN',
    'GDNS':'GDNS',
    'GLD':'GLD',
    'GLEN':'GLEN',
    'GLY':'GLY',
    'GR':'GR',
    'GRA':'GRA',
    'GRN':'GRN',
    'GRND':'GRND',
    'GTE':'GTE',
    'GTES':'GTES',
    'HILL':'HILL',
    'HRD':'HRD',
    'HTS':'HTS',
    'HWY':'HWY',
    'INTG':'INTG',
    'INTN':'INTN',
    'JNC':'JNC',
    'KEY':'KEY',
    'LANE':'LANE',
    'LDG':'LDG',
    'LEES':'LEES',
    'LINE':'LINE',
    'LINK':'LINK',
    'LKT':'LKT',
    'LNWY':'LNWY',
    'LOOP':'LOOP',
    'LT':'LT',
    'LWR':'LWR',
    'MALL':'MALL',
    'MEW':'MEW',
    'MEWS':'MEWS',
    'MNDR':'MNDR',
    'MT':'MT',
    'MWY':'MWY',
    'NOOK':'NOOK',
    'OTLK':'OTLK',
    'PARK':'PARK',
    'PART':'PART',
    'PASS':'PASS',
    'PATH':'PATH',
    'PDE':'PDE',
    'PHWY':'PHWY',
    'PIAZ':'PIAZ',
    'PKLD':'PKLD',
    'PKT':'PKT',
    'PKWY':'PKWY',
    'PL':'PL',
    'PLAT':'PLAT',
    'PLZA':'PLZA',
    'PNT':'PNT',
    'PORT':'PORT',
    'PROM':'PROM',
    'QDGL':'QDGL',
    'QDRT':'QDRT',
    'QUAD':'QUAD',
    'QY':'QY',
    'QYS':'QYS',
    'RAMP':'RAMP',
    'RCH':'RCH',
    'RD':'RD',
    'RDGE':'RDGE',
    'RDS':'RDS',
    'RDSD':'RDSD',
    'RDWY':'RDWY',
    'RES':'RES',
    'REST':'REST',
    'RGWY':'RGWY',
    'RIDE':'RIDE',
    'RING':'RING',
    'RISE':'RISE',
    'RMBL':'RMBL',
    'RND':'RND',
    'RNDE':'RNDE',
    'RNGE':'RNGE',
    'ROW':'ROW',
    'ROWY':'ROWY',
    'RSBL':'RSBL',
    'RTE':'RTE',
    'RTT':'RTT',
    'RTY':'RTY',
    'RUE':'RUE',
    'RUN':'RUN',
    'RVR':'RVR',
    'RVRA':'RVRA',
    'RVWY':'RVWY',
    'SBWY':'SBWY',
    'SDNG':'SDNG',
    'SHWY':'SHWY',
    'SLPE':'SLPE',
    'SND':'SND',
    'SPUR':'SPUR',
    'SQ':'SQ',
    'ST':'ST',
    'STPS':'STPS',
    'STRA':'STRA',
    'STRP':'STRP',
    'STRS':'STRS',
    'SWY':'SWY',
    'TARN':'TARN',
    'TCE':'TCE',
    'THOR':'THOR',
    'TKWY':'TKWY',
    'TLWY':'TLWY',
    'TOP':'TOP',
    'TOR':'TOR',
    'TRI':'TRI',
    'TRK':'TRK',
    'TRL':'TRL',
    'TRLR':'TRLR',
    'TURN':'TURN',
    'TWRS':'TWRS',
    'UPAS':'UPAS',
    'UPR':'UPR',
    'VALE':'VALE',
    'VDCT':'VDCT',
    'VIEW':'VIEW',
    'VLLS':'VLLS',
    'VSTA':'VSTA',
    'WADE':'WADE',
    'WALK':'WALK',
    'WAY':'WAY',
    'WHRF':'WHRF',
    'WKWY':'WKWY',
    'WYND':'WYND',
    'YARD':'YARD',
    
    Alley:'AL',
    Arcade:'ARC',
    Avenue:'AVE',
    Boulevard:'BLV',
    Bend:'BND',
    Bypass:'BPS',
    Brace:'BR',
    Circuit:'CCT',
    Chase:'CH',
    Circle:'CIR',
    Close:'CL',
    Common:'CMN',
    Concourse:'CNC',
    Corner:'CNR',
    Circus:'CRC',
    Crescent:'CRS',
    Crossing:'CSG',
    Corso:'CSO',
    Court:'CT',
    Centre:'CTR',
    Cove:'CVE',
    Causeway:'CWY',
    Drive:'DR',
    Driveway:'DRY',
    Entrance:'ENT',
    Esplanade:'ESP',
    Expressway:'EXP',
    Fairway:'FAY',
    Frontage:'FR',
    Freeway:'FWY',
    Garden:'GDN',
    Glade:'GL',
    Glen:'GLN',
    Grange:'GRA',
    Ground:'GRD',
    Green:'GRN',
    Gate:'GTE',
    Grove:'GVE',
    Heights:'HTS',
    Highway:'HWY',
    Junction:'JN',
    Key:'KEY',
    Lane:'LA',
    Link:'LK',
    Loop:'LP',
    Mall:'ML',
    Mount:'MT',
    Mews:'MW',
    Motorway:'MWY',
    Nook:'NK',
    Outlook:'OUT',
    Parade:'PDE',
    Place:'PL',
    Plaza:'PLZ',
    Point:'PNT',
    Promenade:'PRM',
    Pass:'PSS',
    Path:'PT',
    Parkway:'PWY',
    Quadrant:'QD',
    Quadrangle:'QDG',
    Quay:'QY',
    Ramble: 'RMBL',
    Road:'RD',
    Ridge:'RDGE',
    Roadway:'RDY',
    Reserve:'RES',
    Rise:'RI',
    Round:'RN',
    Row:'ROW',
    Rest:'RST',
    Retreat:'RT',
    Route:'RTE',
    'Right of Way':'RTW',
    Siding:'SDG',
    Square:'SQ',
    Street:'ST',
    STS:'ST',
    Streets:'STS',
    Terrace:'TCE',
    Track:'TR',
    Trail:'TRL',
    Tollway:'TWY',
    View:'VW',
    Way:'WAY',
    Walk:'WK',
    Walkway:'WKY',
    Wynd:'WND'
  };

  var State_Code = {
    "New South Wales" : "NSW",
    "Northern Territory	" : "NT",
    "Queensland" : "QLD",
    "South Australia" : "SA",
    "Tasmania" : "TAS",
    "Victoria" : "VIC",
    "Western Australia" : "WA"
  };

  var Direction_Code;
  var initialized = false;

  var Normalize_Map = {
    type: Street_Type,
    type1: Street_Type,
    type2: Street_Type,
    state: State_Code,
  }

  function capitalize(s){
    return s && s[0].toUpperCase() + s.slice(1);
  }
  function keys(o){
    return Object.keys(o);
  }
  function values(o){
    var v = [];
    keys(o).forEach(function(k){
      v.push(o[k]);
    });
    return v;
  }
  function each(o,fn){
    keys(o).forEach(function(k){
      fn(o[k],k);
    });
  }
  function invert(o){
    var o1= {};
    keys(o).forEach(function(k){
      o1[o[k]] = k;
    });
    return o1;
  }
  function flatten(o){
    return keys(o).concat(values(o));
  }
  function lazyInit(){
    if (initialized) {
      return;
    }
    initialized = true;

    MatchedAddress = {
      type    : flatten(Street_Type).sort().filter(function(v,i,arr){return arr.indexOf(v)===i }).join('|'),
      fraction : '\\d+\\/\\d+',
      state   : '\\b(?:' + keys(State_Code).concat(values(State_Code)).map(XRegExp.escape).join('|') + ')\\b',
      postcode     : '(?<postcode>\\d{4})[- ]?(?<plus4>\\d{4})?',
      corner  : '(?:\\band\\b|\\bat\\b|&|\\@)',
    };

    MatchedAddress.streetNameNumber = '(?<streetNumber>\\d+-?\\d*)(?=\\D)';

    MatchedAddress.streetName = '                                       \n\
      (?:                                                       \n\
        (?:(?<streetName_0>'+MatchedAddress.direct+')\\W+               \n\
           (?<streetType_0>'+MatchedAddress.type+')\\b                    \n\
        )                                                       \n\
        |                                                       \n\
        (?:(?<prefix_0>'+MatchedAddress.direct+')\\W+)?               \n\
        (?:                                                     \n\
          (?<streetName_1>[^,]*\\d)                                 \n\
          (?:[^\\w,]*(?<suffix_1>'+MatchedAddress.direct+')\\b)     \n\
          |                                                     \n\
          (?<streetName_2>[^,]+)                                    \n\
          (?:[^\\w,]+(?<streetType_2>'+MatchedAddress.type+')\\b)         \n\
          (?:[^\\w,]+(?<suffix_2>'+MatchedAddress.direct+')\\b)?    \n\
          |                                                     \n\
          (?<street_3>[^,]+?)                                   \n\
          (?:[^\\w,]+(?<streetType_3>'+MatchedAddress.type+')\\b)?        \n\
          (?:[^\\w,]+(?<suffix_3>'+MatchedAddress.direct+')\\b)?    \n\
        )                                                       \n\
      )';

    MatchedAddress.unitType_numbered = '             \n\
      (?<unitType_1>su?i?te                      \n\
        |p\\W*[om]\\W*b(?:ox)?                        \n\
        |(?:ap|dep)(?:ar)?t(?:me?nt)?                 \n\
        |ro*m                                         \n\
        |flo*r?                                       \n\
        |uni?t                                        \n\
        |bu?i?ldi?n?g                                 \n\
        |ha?nga?r                                     \n\
        |lo?t                                         \n\
        |pier                                         \n\
        |slip                                         \n\
        |spa?ce?                                      \n\
        |stop                                         \n\
        |tra?i?le?r                                   \n\
        |PO box                                   \n\
        |P.O. box)(?![a-z]                                 \n\
      )                                               \n\
      ';

    MatchedAddress.unitType_unnumbered = '           \n\
      (?<unitType_2>ba?se?me?n?t                 \n\
        |fro?nt                                       \n\
        |lo?bby                                       \n\
        |lowe?r                                       \n\
        |off?i?ce?                                    \n\
        |pe?n?t?ho?u?s?e?                             \n\
        |rear                                         \n\
        |side                                         \n\
        |uppe?r                                       \n\
      )\\b';

    MatchedAddress.sec_unit = '                               \n\
      (?:                               #fix3             \n\
        (?:                             #fix1             \n\
          (?:                                             \n\
            (?:'+MatchedAddress.unitType_numbered+'\\W*) \n\
            |(?<unitType_3>\\#)\\W*                  \n\
          )                                               \n\
          (?<unitNumber_1>[\\w-]+)                      \n\
        )                                                 \n\
        |                                                 \n\
        '+MatchedAddress.unitType_unnumbered+'           \n\
      )';

    MatchedAddress.suburb_and_state = '                       \n\
      (?:                                               \n\
        (?<suburb>[^\\d,]+?)\\W+                          \n\
        (?<state>'+MatchedAddress.state+')                  \n\
      )                                                 \n\
      ';

    MatchedAddress.place = '                                \n\
      (?:'+MatchedAddress.suburb_and_state+'\\W*)?            \n\
      (?:'+MatchedAddress.postcode+')?                           \n\
      ';

    MatchedAddress.address = XRegExp('                      \n\
      ^                                                 \n\
      [^\\w\\#]*                                        \n\
      ('+MatchedAddress.streetNameNumber+')\\W*                       \n\
      (?:'+MatchedAddress.fraction+'\\W*)?                  \n\
         '+MatchedAddress.streetName+'\\W+                      \n\
      (?:'+MatchedAddress.sec_unit+')?\\W*          #fix2   \n\
         '+MatchedAddress.place+'                           \n\
      \\W*$','ix');

    var sep = '(?:\\W+|$)'; // no support for \Z

    MatchedAddress.informal_address = XRegExp('                   \n\
      ^                                                       \n\
      \\s*                                                    \n\
      (?:'+MatchedAddress.sec_unit+sep+')?                        \n\
      (?:'+MatchedAddress.streetNameNumber+')?\\W*                          \n\
      (?:'+MatchedAddress.fraction+'\\W*)?                        \n\
         '+MatchedAddress.streetName+sep+'                            \n\
      (?:'+MatchedAddress.sec_unit.replace(/_\d/g,'$&1')+sep+')?  \n\
      (?:'+MatchedAddress.place+')?                               \n\
      ','ix');

    MatchedAddress.intersection = XRegExp('                     \n\
      ^\\W*                                                 \n\
      '+MatchedAddress.streetName.replace(/_\d/g,'1$&')+'\\W*?      \n\
      \\s+'+MatchedAddress.corner+'\\s+                         \n\
      '+MatchedAddress.streetName.replace(/_\d/g,'2$&') + '\\W+     \n\
      '+MatchedAddress.place+'\\W*$','ix');
  }
  parser.normalize_address = function(parts){
    lazyInit();
    if(!parts)
      return null;
    var parsed = {};

    Object.keys(parts).forEach(function(k){
      if(['input','index'].indexOf(k) !== -1 || isFinite(k))
        return;
      var key = isFinite(k.split('_').pop())? k.split('_').slice(0,-1).join('_'): k ;
      if(parts[k])
        parsed[key] = parts[k].trim().replace(/^\s+|\s+$|[^\w\s\-#&]/g, '');
    });
    each(Normalize_Map, function(map,key) {
      if(parsed[key] && map[parsed[key].toLowerCase()]) {
        parsed[key] = map[parsed[key].toLowerCase()];
      }
    });

    ['type', 'type1', 'type2'].forEach(function(key){
      if(key in parsed)
        parsed[key] = parsed[key].charAt(0).toUpperCase() + parsed[key].slice(1).toLowerCase();
    });

    // Handle post box address
    if(typeof parsed.unitType !== "undefined"){
        if(parsed.unitType.replace(/\s/g, '').toLowerCase()=='pobox'){
            parts.input = parts.input.replace(/\./g, "");
            var suburbAndState = 'street' + parts.input.replace(parsed.unitType,'').replace(parsed.unitNumber,'');
            var postBoxLocation = parser.parseLocation(suburbAndState);
            delete postBoxLocation.streetNumber;
            delete postBoxLocation.street;
            postBoxLocation.propertyName = parsed.unitType + ' ' + parsed.unitNumber;
            return postBoxLocation;
        }
    }

    if (typeof parsed.streetType !== "undefined") parsed.streetType = shortenStreetType(parsed.streetType);
    if (typeof parsed.streetType1 !== "undefined") parsed.streetType1 = shortenStreetType(parsed.streetType1);
    if (typeof parsed.streetType2 !== "undefined") parsed.streetType2 = shortenStreetType(parsed.streetType2);

    // Handle Intersection
    if (typeof parsed.streetName1 !== "undefined" || typeof parsed.streetName2 !== "undefined" || typeof parsed.streetType1 !== "undefined" || typeof parsed.streetType2 !== "undefined" ){

        if(typeof parsed.streetType1 == "undefined" && typeof parsed.streetType2 !== "undefined"){
          parsed.streetType1 = parsed.streetType2;
          if(typeof parsed.streetName1 == "undefined" && typeof parsed.street1 !== "undefined"){
            parsed.streetName1 = parsed.street1;
            delete(parsed.street1)
          }
        }
        parsed.streetName1 = parsed.streetName1.replace(/^(Crn|Cnr of|Cnr|Corner)/g, "");
        parsed.streetName = parsed.streetName1 + ' ' +  parsed.streetType1 + ' & ' + parsed.streetName2 + ' ' + parsed.streetType2;
    }

    if(parsed.suburb){
      parsed.suburb = titleCase(parsed.suburb);
      parsed.suburb = XRegExp.replace(parsed.suburb,
        XRegExp('^(?<dircode>'+MatchedAddress.dircode+')\\s+(?=\\S)','ix'),
        function(match){
          return capitalize(Direction_Code[match.dircode.toUpperCase()]) +' ';
        });
    }

    Object.keys(parsed).forEach(function(key){
      if (typeof parsed[key] !== "undefined") parsed[key] = parsed[key].trim();
    })

    return parsed;
  };

  parser.parseAddress = function(address){
    lazyInit();
    var parts = XRegExp.exec(address,MatchedAddress.address);
    return parser.normalize_address(parts);
  };
  parser.parseInformalAddress = function(address){
    lazyInit();
    var parts = XRegExp.exec(address,MatchedAddress.informal_address);
    return parser.normalize_address(parts);
  };
  parser.parseLocation = function(address){
    address = optimiseAddress(address);
    lazyInit();
    if (XRegExp(MatchedAddress.corner,'xi').test(address)) {
        return parser.parseIntersection(address);
    }
    return parser.parseAddress(address)
        || parser.parseInformalAddress(address);
  };
  parser.parseIntersection = function(address){
    lazyInit();
    var parts = XRegExp.exec(address,MatchedAddress.intersection);
    parts = parser.normalize_address(parts);
    // if(parts){
    //     // parts.type2 = parts.type2 || '';
    //     // parts.type1 = parts.type1 || '';
    //     if (parts.type2 && !parts.type1 || (parts.type1 === parts.type2)) {
    //         var type = parts.type2;
    //         type = XRegExp.replace(type,/s\W*$/,'');
    //         if (XRegExp('^'+MatchedAddress.type+'$','ix').test(type)) {
    //             parts.type1 = parts.type2 = type;
    //         }
    //     }
    // }

    return parts;
  };

  function optimiseAddress(address){   
    // If there is a unit character
    if (!isNaN(address.substr(0,address.indexOf(' '))[0])){
        var unitNumber = address.match(/\d+([a-zA-Z]?)/)[0];
        var unitChracter = address.match(/\d+([a-zA-Z]?)/)[1];
        if (unitChracter!=''){

          address = 'unit '+unitChracter+' '+address.substr(address.indexOf(' ')+1);
        }
    }


    //  Remove brankets and contents in address
    return address.replace(/\s*\([^)]*\)/g, "").replace(/\s-\s/g,"-");
  }

  function shortenStreetType(streetType){
    // Street_Type.map((s)=>{
    //   console.log(s);
    // })
    if (typeof Street_Type[streetType] !== "undefined") return Street_Type[streetType];
    return streetType;
  }

  function titleCase(str) {
    var splitStr = str.toLowerCase().split(' ');
    for (var i = 0; i < splitStr.length; i++) {
        // You do not need to check if i is larger than splitStr length, as your for does that for you
        // Assign it back to the array
        splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);     
    }
    // Directly return the joined string
    return splitStr.join(' '); 
  }

  // AMD / RequireJS
  if (typeof define !== 'undefined' && define.amd) {
      define([], function () {
          return parser;
      });
  }
  // Node.js
  else if (typeof exports !== "undefined") {
    exports.parseIntersection = parser.parseIntersection;
    exports.parseLocation = parser.parseLocation;
    exports.parseInformalAddress = parser.parseInformalAddress;
    exports.parseAddress = parser.parseAddress;
  }
  // included directly via <script> tag
  else {
      root.addressParser = root.addressParser || parser;
  }

}());