lightning-base-components 1.21.2-alpha → 1.21.4-alpha

package/src/lightning/internationalizationLibrary/address/AddressFormat.js

@@ -4,15 +4,117 @@
 // And add "export { address };" at the end.
 
 /* eslint-disable */
-var data = {
+function _toPrimitive(t, r) {
+    if ('object' != typeof t || !t) return t;
+    let e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+        let i = e.call(t, r || 'default');
+        if ('object' != typeof i) return i;
+        throw new TypeError('@@toPrimitive must return a primitive value.');
+    }
+    return ('string' === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+    let i = _toPrimitive(t, 'string');
+    return 'symbol' == typeof i ? i : String(i);
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError('Cannot call a class as a function');
+    }
+}
+function _defineProperties(target, props) {
+    for (let i = 0; i < props.length; i++) {
+        let descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ('value' in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, 'prototype', {
+        writable: false,
+    });
+    return Constructor;
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
+    let n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === 'Object' && o.constructor) n = o.constructor.name;
+    if (n === 'Map' || n === 'Set') return Array.from(o);
+    if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+    let it = typeof Symbol !== 'undefined' && o[Symbol.iterator] || o['@@iterator'];
+    if (!it) {
+        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === 'number') {
+            if (it) o = it;
+            let i = 0;
+            let F = function() {};
+            return {
+                s: F,
+                n: function() {
+                    if (i >= o.length) {
+                        return {
+                            done: true,
+                        };
+                    }
+                    return {
+                        done: false,
+                        value: o[i++],
+                    };
+                },
+                e: function(e) {
+                    throw e;
+                },
+                f: F,
+            };
+        }
+        throw new TypeError('Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
+    }
+    let normalCompletion = true;
+    let didErr = false;
+    let err;
+    return {
+        s: function() {
+            it = it.call(o);
+        },
+        n: function() {
+            let step = it.next();
+            normalCompletion = step.done;
+            return step;
+        },
+        e: function(e) {
+            didErr = true;
+            err = e;
+        },
+        f: function() {
+            try {
+                if (!normalCompletion && it.return != null) it.return();
+            } finally {
+                if (didErr) throw err;
+            }
+        },
+    };
+}
+let data = {
     AE: {
         fmt: '%A%n%S%n%K',
-        require: 'AS',
+        require: 'ASK',
         input: 'ASK',
     },
     AL: {
         fmt: '%A%n%Z%n%C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     EC: {
@@ -26,12 +128,12 @@ var data = {
     },
     AM: {
         fmt: '%A%n%Z%n%C%n%S%n%K',
-        require: 'AZCS',
+        require: 'AZK',
         input: 'AZK',
     },
     AR: {
         fmt: '%A%n%Z %C%n%S%n%K',
-        require: 'AZCS',
+        require: 'AZCSK',
         input: 'AZCSK',
     },
     CL: {
@@ -48,7 +150,7 @@ var data = {
     },
     AT: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     BA: {
@@ -60,6 +162,9 @@ var data = {
     CH: {
         _ref: 'AT',
     },
+    CY: {
+        _ref: 'AT',
+    },
     DE: {
         _ref: 'AT',
     },
@@ -84,6 +189,9 @@ var data = {
     GE: {
         _ref: 'AT',
     },
+    GL: {
+        _ref: 'AT',
+    },
     GR: {
         _ref: 'AT',
     },
@@ -152,7 +260,7 @@ var data = {
     },
     AU: {
         fmt: '%A%n%C %S %Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     CA: {
@@ -160,12 +268,12 @@ var data = {
     },
     AZ: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     AF: {
         fmt: '%A%n%C%n%Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACZK',
     },
     FK: {
@@ -173,7 +281,7 @@ var data = {
     },
     GB: {
         fmt: '%A%n%C%n%S%n%Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACSZK',
     },
     KE: {
@@ -193,7 +301,7 @@ var data = {
     },
     US: {
         fmt: '%A%n%C, %S %Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     BB: {
@@ -207,7 +315,7 @@ var data = {
     },
     ES: {
         fmt: '%A%n%Z %C %S%n%K',
-        require: 'AZCS',
+        require: 'AZCSK',
         input: 'AZCSK',
     },
     IT: {
@@ -218,7 +326,7 @@ var data = {
     },
     ID: {
         fmt: '%A%n%C%n%S %Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     IE: {
@@ -232,12 +340,12 @@ var data = {
     },
     HU: {
         fmt: '%C%n%A%n%Z%n%K',
-        require: 'CAZ',
+        require: 'CAZK',
         input: 'CAZK',
     },
     BH: {
         fmt: '%A%n%C %Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACZK',
     },
     BM: {
@@ -272,37 +380,37 @@ var data = {
     },
     BD: {
         fmt: '%A%n%C - %Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACZK',
     },
     BR: {
         fmt: '%A%n%C-%S%n%Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     CN: {
         fmt: '%K%n%S %C%n%A%n%Z',
-        require: 'CAZ',
+        require: 'KCAZ',
         input: 'KSCAZ',
     },
     HK: {
         fmt: '%K%S%C%n%A%n%Z',
-        require: 'CA',
+        require: 'KCA',
         input: 'KSCAZ',
     },
     CO: {
         fmt: '%A%n%C, %S, %Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     CR: {
         fmt: '%A%n%S, %C%n%Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ASCZK',
     },
     EG: {
         fmt: '%A%n%C%n%S%n%Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     RU: {
@@ -313,17 +421,17 @@ var data = {
     },
     FI: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     GT: {
         fmt: '%A%n%Z-%C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     HN: {
         fmt: '%A%n%C, %S%n%Z%n%K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     IQ: {
@@ -331,17 +439,17 @@ var data = {
     },
     HR: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     HT: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     IN: {
         fmt: '%A%n%C %Z%n%S%n%K',
-        require: 'ACZS',
+        require: 'ACZSK',
         input: 'ACZSK',
     },
     NG: {
@@ -352,12 +460,12 @@ var data = {
     },
     IR: {
         fmt: '%S%n%C%n%A%n%Z%n%K',
-        require: 'SCAZ',
+        require: 'SCAZK',
         input: 'SCAZK',
     },
     JM: {
         fmt: '%A%n%C%n%S%n%K',
-        require: 'ACS',
+        require: 'ACSK',
         input: 'ACSK',
     },
     PA: {
@@ -370,44 +478,43 @@ var data = {
         _ref: 'JM',
     },
     JP: {
-        // Escape non-ASCII character. Aura component test cannot parse non-ASCII string properly.
-        fmt: '%K%n' + String.fromCharCode(12306) + '%Z%n%S %C%n%A',
-        require: 'ZCA',
+        fmt: '%K%n〒%Z%n%S %C%n%A',
+        require: 'KZCA',
         input: 'KZSCA',
     },
     EN_JP: {
         fmt: '%A%n%C %S%n%Z %K',
-        require: 'ACSZ',
+        require: 'ACSZK',
         input: 'ACSZK',
     },
     KG: {
         fmt: '%Z %C%n%A%n%S%n%K',
-        require: 'ZCA',
+        require: 'ZCAK',
         input: 'ZCAK',
     },
     KR: {
         fmt: '%S %C%n%A%n%Z%n%K',
-        require: 'SCAZ',
+        require: 'SCAZK',
         input: 'SCAZK',
     },
     KY: {
         fmt: '%A%n%S %Z%n%K',
-        require: 'ASZ',
+        require: 'ASZK',
         input: 'ASZK',
     },
     KZ: {
         fmt: '%Z%n%S%n%C%n%A%n%K',
-        require: 'ZSCA',
+        require: 'ZSCAK',
         input: 'ZSCAK',
     },
     LT: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     LV: {
         fmt: '%A%n%C, %Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACZK',
     },
     MM: {
@@ -415,157 +522,169 @@ var data = {
     },
     MC: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     MD: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     MW: {
         fmt: '%A%n%C%n%K',
-        require: 'AC',
+        require: 'ACK',
         input: 'ACK',
     },
     MX: {
         fmt: '%A%n%Z %C, %S%n%K',
-        require: 'AZCS',
+        require: 'AZCSK',
         input: 'AZCSK',
     },
     NI: {
         fmt: '%A%n%Z%n%C, %S%n%K',
-        require: 'AZCS',
+        require: 'AZCSK',
         input: 'AZCSK',
     },
     PG: {
         fmt: '%A%n%C %Z %S%n%K',
-        require: 'ACZS',
+        require: 'ACZSK',
         input: 'ACZSK',
     },
     PH: {
         fmt: '%A, %C%n%Z %S%n%K',
-        require: 'ACZS',
+        require: 'ACZSK',
         input: 'ACZSK',
     },
     PK: {
         fmt: '%A%n%C-%Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACZK',
     },
     PR: {
         fmt: '%A%n%C %Z%n%K',
-        require: 'ACZ',
+        require: 'ACZK',
         input: 'ACZK',
     },
     SE: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     SG: {
         fmt: '%A%n%C %Z%n%S%n%K',
-        require: 'AZ',
+        require: 'AZK',
         input: 'AZK',
     },
     SI: {
         fmt: '%A%n%Z %C%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     SV: {
         fmt: '%A%n%Z-%C%n%S%n%K',
-        require: 'AZCS',
+        require: 'AZCSK',
         input: 'AZCSK',
     },
     TR: {
         fmt: '%A%n%Z %C/%S%n%K',
-        require: 'AZC',
+        require: 'AZCK',
         input: 'AZCK',
     },
     TW: {
         fmt: '%K%n%Z%n%S %C%n%A',
-        require: 'ZSCA',
+        require: 'KZSCA',
         input: 'KZSCA',
     },
     VE: {
         fmt: '%A%n%C %Z, %S%n%K',
-        require: 'ACZS',
+        require: 'ACZSK',
         input: 'ACZSK',
     },
 };
-
-var languageCodeToCountry = {
+let languageCodeToCountry = {
     languageCode: {
-        ar: 'AE',
-        af: 'ZA',
-        bg: 'BG',
-        bn: 'BN',
-        bs: 'BA',
-        ca: 'ES',
-        cs: 'CZ',
-        cy: 'GB',
-        da: 'DK',
-        de: 'DE',
-        el: 'GR',
-        es: 'ES',
-        et: 'ET',
-        eu: 'ES',
-        fi: 'FI',
-        fr: 'FR',
-        ga: 'IE',
-        gu: 'IN',
-        hi: 'IN',
-        hr: 'HR',
-        hu: 'HU',
-        hy: 'HY',
-        in: 'ID',
-        is: 'IS',
-        it: 'IT',
-        iw: 'IL',
-        ja: 'JP',
-        ka: 'GE',
-        kn: 'IN',
-        ko: 'KR',
-        lb: 'LU',
-        lt: 'IT',
-        lv: 'LV',
-        mk: 'MK',
-        ml: 'IN',
-        mr: 'IN',
-        ms: 'MY',
-        mt: 'MT',
-        nl: 'NL',
-        no: 'NO',
-        pl: 'PL',
-        pt: 'PT',
-        rm: 'DE',
-        ro: 'RO',
-        ru: 'RU',
-        sh: 'BA',
-        sk: 'SK',
-        sl: 'SL',
-        sq: 'SQ',
-        sr: 'RS',
-        sv: 'SE',
-        sw: 'ZA',
-        ta: 'IN',
-        te: 'IN',
-        th: 'TH',
-        tl: 'PH',
-        tr: 'TR',
-        uk: 'UK',
-        ur: 'IN',
-        vi: 'VN',
-        xh: 'ZA',
-        zh: 'CN',
-        zu: 'ZA',
+        'af': 'ZA',
+        'am': 'ET',
+        'ar': 'AE',
+        'bg': 'BG',
+        'bn': 'BD',
+        'bs': 'BA',
+        'ca': 'ES',
+        'cs': 'CZ',
+        'cy': 'GB',
+        'da': 'DK',
+        'de': 'DE',
+        'el': 'GR',
+        'es': 'ES',
+        'et': 'EE',
+        'eu': 'ES',
+        'fa': 'IR',
+        'fi': 'FI',
+        'fr': 'FR',
+        'ga': 'IE',
+        'gu': 'IN',
+        'haw': 'US',
+        'hi': 'IN',
+        'hmn': 'US',
+        'hr': 'HR',
+        'ht': 'HT',
+        'hu': 'HU',
+        'hy': 'AM',
+        'in': 'ID',
+        'is': 'IS',
+        'it': 'IT',
+        'iw': 'IL',
+        'ja': 'JP',
+        'ji': 'IL',
+        'ka': 'GE',
+        'kk': 'KZ',
+        'kl': 'GL',
+        'km': 'KH',
+        'kn': 'IN',
+        'ko': 'KR',
+        'lb': 'LU',
+        'lt': 'LT',
+        'lv': 'LV',
+        'mi': 'NZ',
+        'mk': 'MK',
+        'ml': 'IN',
+        'mr': 'IN',
+        'ms': 'MY',
+        'mt': 'MT',
+        'my': 'MM',
+        'nl': 'NL',
+        'no': 'NO',
+        'pa': 'IN',
+        'pl': 'PL',
+        'pt': 'PT',
+        'rm': 'CH',
+        'ro': 'RO',
+        'ru': 'RU',
+        'sh': 'RS',
+        'sk': 'SK',
+        'sl': 'SL',
+        'sm': 'WS',
+        'sq': 'AL',
+        'sr': 'RS',
+        'sv': 'SE',
+        'sw': 'ZA',
+        'ta': 'IN',
+        'te': 'IN',
+        'th': 'TH',
+        'tl': 'PH',
+        'tr': 'TR',
+        'uk': 'UA',
+        'ur': 'IN',
+        'vi': 'VN',
+        'xh': 'ZA',
+        'zh': 'CN',
+        'zu': 'ZA',
     },
 };
 
 /**
- * Define address format patterns.
- */
+     * Define address format patterns.
+     */
 var AddressFormatPattern = Object.freeze({
     /**
      *
@@ -588,89 +707,65 @@ var AddressFormatPattern = Object.freeze({
     n: Symbol('New Line'),
     fromPlaceHolder: function fromPlaceHolder(placeHolder) {
         switch (placeHolder) {
-            case 'A':
-                return AddressFormatPattern.A;
-            case 'C':
-                return AddressFormatPattern.C;
-            case 'S':
-                return AddressFormatPattern.S;
-            case 'K':
-                return AddressFormatPattern.K;
-            case 'Z':
-                return AddressFormatPattern.Z;
-            case 'n':
-                return AddressFormatPattern.n;
+        case 'A':
+            return AddressFormatPattern.A;
+        case 'C':
+            return AddressFormatPattern.C;
+        case 'S':
+            return AddressFormatPattern.S;
+        case 'K':
+            return AddressFormatPattern.K;
+        case 'Z':
+            return AddressFormatPattern.Z;
+        case 'n':
+            return AddressFormatPattern.n;
         }
         return null;
     },
     getPlaceHolder: function getPlaceHolder(pattern) {
         switch (pattern) {
-            case AddressFormatPattern.A:
-                return 'A';
-            case AddressFormatPattern.C:
-                return 'C';
-            case AddressFormatPattern.S:
-                return 'S';
-            case AddressFormatPattern.K:
-                return 'K';
-            case AddressFormatPattern.Z:
-                return 'Z';
-            case AddressFormatPattern.n:
-                return 'n';
+        case AddressFormatPattern.A:
+            return 'A';
+        case AddressFormatPattern.C:
+            return 'C';
+        case AddressFormatPattern.S:
+            return 'S';
+        case AddressFormatPattern.K:
+            return 'K';
+        case AddressFormatPattern.Z:
+            return 'Z';
+        case AddressFormatPattern.n:
+            return 'n';
         }
         return null;
     },
     getData: function getData(pattern, data) {
         if (data) {
             switch (pattern) {
-                case AddressFormatPattern.A:
-                    return data.address;
-                case AddressFormatPattern.C:
-                    return data.city;
-                case AddressFormatPattern.S:
-                    return data.state;
-                case AddressFormatPattern.K:
-                    return data.country;
-                case AddressFormatPattern.Z:
-                    return data.zipCode;
-                case AddressFormatPattern.n:
-                    return data.newLine;
+            case AddressFormatPattern.A:
+                return data.address;
+            case AddressFormatPattern.C:
+                return data.city;
+            case AddressFormatPattern.S:
+                return data.state;
+            case AddressFormatPattern.K:
+                return data.country;
+            case AddressFormatPattern.Z:
+                return data.zipCode;
+            case AddressFormatPattern.n:
+                return data.newLine;
             }
         }
         return null;
     },
 });
 
-var classCallCheck = function(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError('Cannot call a class as a function');
-    }
-};
-
-var createClass = (function() {
-    function defineProperties(target, props) {
-        for (var i = 0; i < props.length; i++) {
-            var descriptor = props[i];
-            descriptor.enumerable = descriptor.enumerable || false;
-            descriptor.configurable = true;
-            if ('value' in descriptor) descriptor.writable = true;
-            Object.defineProperty(target, descriptor.key, descriptor);
-        }
-    }
-
-    return function(Constructor, protoProps, staticProps) {
-        if (protoProps) defineProperties(Constructor.prototype, protoProps);
-        if (staticProps) defineProperties(Constructor, staticProps);
-        return Constructor;
-    };
-})();
-
 /**
- * Address token types enum
- *
- * @private
- */
-var AddressTokenTypes = Object.freeze({
+     * Address token types enum
+     *
+     * @private
+     */
+let AddressTokenTypes = Object.freeze({
     DATA: Symbol('data'),
     STRING: Symbol('string'),
     NEWLINE: Symbol('newline'),
@@ -678,12 +773,11 @@ var AddressTokenTypes = Object.freeze({
 });
 
 /**
- * AddressToken class
- *
- * @private
- */
-
-var AddressToken = (function() {
+     * AddressToken class
+     *
+     * @private
+     */
+let AddressToken = /* #__PURE__*/function() {
     /**
      *
      * @param {AddressTokenTypes} type
@@ -691,8 +785,7 @@ var AddressToken = (function() {
      * @param {*} pattern
      */
     function AddressToken(type, string, pattern) {
-        classCallCheck(this, AddressToken);
-
+        _classCallCheck(this, AddressToken);
         this.type = type;
         this.string = string;
         this.pattern = pattern;
@@ -704,52 +797,41 @@ var AddressToken = (function() {
      * @param {string} string String
      * @return {AddressToken} Address Token
      */
-
-    createClass(AddressToken, null, [
-        {
-            key: 'string',
-            value: function string(_string) {
-                return new AddressToken(AddressTokenTypes.STRING, _string);
-            },
-            /**
-             * Construct a data type token
-             *
-             * @param {pattern} pattern Address Format Pattern
-             * @return {AddressToken} Address Token
-             */
+    _createClass(AddressToken, null, [{
+        key: 'string',
+        value: function string(_string) {
+            return new AddressToken(AddressTokenTypes.STRING, _string);
         },
-        {
-            key: 'data',
-            value: function data(pattern) {
-                return new AddressToken(
-                    AddressTokenTypes.DATA,
-                    undefined,
-                    pattern
-                );
-            },
-            /**
-             * Construct a new line type token
-             *
-             * @return {AddressToken} Address Token
-             */
+        /**
+         * Construct a data type token
+         *
+         * @param {pattern} pattern Address Format Pattern
+         * @return {AddressToken} Address Token
+         */
+    }, {
+        key: 'data',
+        value: function data(pattern) {
+            return new AddressToken(AddressTokenTypes.DATA, undefined, pattern);
         },
-        {
-            key: 'newLine',
-            value: function newLine() {
-                return new AddressToken(AddressTokenTypes.NEWLINE);
-            },
+        /**
+         * Construct a new line type token
+         *
+         * @return {AddressToken} Address Token
+         */
+    }, {
+        key: 'newLine',
+        value: function newLine() {
+            return new AddressToken(AddressTokenTypes.NEWLINE);
         },
-    ]);
+    }]);
     return AddressToken;
-})();
-
-/**
- * TokenizerState class
- *
- * @private
- */
-
-var TokenizerState =
+}();
+    /**
+     * TokenizerState class
+     *
+     * @private
+     */
+let TokenizerState = /* #__PURE__*/_createClass(
     /**
      * Constructor
      *
@@ -757,82 +839,58 @@ var TokenizerState =
      * @param {int} start
      */
     function TokenizerState(pattern, start) {
-        classCallCheck(this, TokenizerState);
-
+        _classCallCheck(this, TokenizerState);
         this.pattern = pattern;
         this.start = start;
-    };
-
-/**
- * Tokenize string pattern to AddressToken array
- *
- * @param {TokenizerState} state
- * @param {AddressToken[]} tokens
- * @return {TokenizerState} Tokenizer state
- *
- * @private
- */
-
+    });
+    /**
+     * Tokenize string pattern to AddressToken array
+     *
+     * @param {TokenizerState} state
+     * @param {AddressToken[]} tokens
+     * @return {TokenizerState} Tokenizer state
+     *
+     * @private
+     */
 function tokenize(state, tokens) {
-    var nextIndex = state.start;
+    let nextIndex = state.start;
     if (state.pattern) {
-        var len = state.pattern.length;
+        let len = state.pattern.length;
         while (state.start < len) {
             nextIndex = state.pattern.indexOf('%', nextIndex);
             if (nextIndex >= 0 && nextIndex + 1 < len) {
-                var placeHolder = state.pattern.substring(
-                    nextIndex + 1,
-                    nextIndex + 2
-                );
+                let placeHolder = state.pattern.substring(nextIndex + 1, nextIndex + 2);
                 switch (placeHolder) {
-                    case 'n': {
+                case 'n':
+                {
+                    if (nextIndex - state.start > 0) {
+                        tokens.push(AddressToken.string(state.pattern.substring(state.start, nextIndex)));
+                    }
+                    tokens.push(AddressToken.newLine());
+                    state.start = nextIndex + 2;
+                    nextIndex = state.start;
+                    break;
+                }
+                default:
+                {
+                    let p = AddressFormatPattern.fromPlaceHolder(placeHolder);
+                    if (p) {
                         if (nextIndex - state.start > 0) {
-                            tokens.push(
-                                AddressToken.string(
-                                    state.pattern.substring(
-                                        state.start,
-                                        nextIndex
-                                    )
-                                )
-                            );
+                            tokens.push(AddressToken.string(state.pattern.substring(state.start, nextIndex)));
                         }
-                        tokens.push(AddressToken.newLine());
+                        tokens.push(AddressToken.data(p));
+                        state.start = nextIndex + 2;
+                        nextIndex = state.start;
+                    } else {
                         state.start = nextIndex + 2;
                         nextIndex = state.start;
-                        break;
-                    }
-                    default: {
-                        var p = AddressFormatPattern.fromPlaceHolder(
-                            placeHolder
-                        );
-                        if (p) {
-                            if (nextIndex - state.start > 0) {
-                                tokens.push(
-                                    AddressToken.string(
-                                        state.pattern.substring(
-                                            state.start,
-                                            nextIndex
-                                        )
-                                    )
-                                );
-                            }
-                            tokens.push(AddressToken.data(p));
-                            state.start = nextIndex + 2;
-                            nextIndex = state.start;
-                        } else {
-                            state.start = nextIndex + 2;
-                            nextIndex = state.start;
-                        }
-                        break;
                     }
+                    break;
+                }
                 }
             } else {
                 if (state.start < len) {
-                    tokens.push(
-                        AddressToken.string(
-                            state.pattern.substring(state.start)
-                        )
-                    );
+                    tokens.push(AddressToken.string(state.pattern.substring(state.start)));
                 }
                 state.start = len;
             }
@@ -842,91 +900,61 @@ function tokenize(state, tokens) {
 }
 
 /**
- * Format line from tokens
- *
- * @param {*} tokens
- * @param {*} data
- * @param {*} ignoreEmptyLines
- * @param {*} firstIndex
- * @param {*} lastIndex
- * @return {string} Formatted line
- *
- * @private
- */
-function formatLineTokens(
-    tokens,
-    data,
-    ignoreEmptyLines,
-    firstIndex,
-    lastIndex
-) {
-    var parts = [];
-    for (var index = firstIndex; index <= lastIndex; index++) {
-        var token = tokens[index];
+     * Format line from tokens
+     *
+     * @param {*} tokens
+     * @param {*} data
+     * @param {*} ignoreEmptyLines
+     * @param {*} firstIndex
+     * @param {*} lastIndex
+     * @return {string} Formatted line
+     *
+     * @private
+     */
+function formatLineTokens(tokens, data, ignoreEmptyLines, firstIndex, lastIndex) {
+    let parts = [];
+    for (let index = firstIndex; index <= lastIndex; index++) {
+        let token = tokens[index];
         if (!token) {
             continue;
         } else if (token.type == AddressTokenTypes.DATA) {
-            // Consume all subsequent data if available
-            var dataBuffer = '';
-            var lastDataIndex = index;
-            for (var dataIndex = index; dataIndex <= lastIndex; dataIndex++) {
-                var dataToken = tokens[dataIndex];
+        // Consume all subsequent data if available
+            let dataBuffer = '';
+            let lastDataIndex = index;
+            for (let dataIndex = index; dataIndex <= lastIndex; dataIndex++) {
+                let dataToken = tokens[dataIndex];
                 if (!dataToken || dataToken.type != AddressTokenTypes.DATA) {
                     break;
                 }
-                var fieldData = AddressFormatPattern.getData(
-                    dataToken.pattern,
-                    data
-                );
+                let fieldData = AddressFormatPattern.getData(dataToken.pattern, data);
                 if (fieldData) {
                     dataBuffer += fieldData;
                     lastDataIndex = dataIndex;
                 }
             }
-            var hasData = dataBuffer && dataBuffer.length > 0;
+            let hasData = dataBuffer && dataBuffer.length > 0;
             // Output previous string only if there is data before it,
             // or if it is the first on the line
-            var hasPreviousData = false;
+            let hasPreviousData = false;
             if (index - 1 >= firstIndex) {
-                var stringToken = tokens[index - 1];
-                if (
-                    stringToken &&
-                    stringToken.type == AddressTokenTypes.STRING &&
-                    stringToken.string
-                ) {
-                    for (
-                        var prevIndex = index - 2;
-                        prevIndex >= firstIndex;
-                        prevIndex--
-                    ) {
-                        var prevToken = tokens[prevIndex];
-                        if (
-                            prevToken &&
-                            prevToken.type == AddressTokenTypes.DATA
-                        ) {
-                            var _fieldData = AddressFormatPattern.getData(
-                                prevToken.pattern,
-                                data
-                            );
+                let stringToken = tokens[index - 1];
+                if (stringToken && stringToken.type == AddressTokenTypes.STRING && stringToken.string) {
+                    for (let prevIndex = index - 2; prevIndex >= firstIndex; prevIndex--) {
+                        let prevToken = tokens[prevIndex];
+                        if (prevToken && prevToken.type == AddressTokenTypes.DATA) {
+                            let _fieldData = AddressFormatPattern.getData(prevToken.pattern, data);
                             if (_fieldData) {
                                 hasPreviousData = true;
                                 break;
                             }
-                        } else if (
-                            prevToken &&
-                            prevToken.type == AddressTokenTypes.STRING
-                        ) {
+                        } else if (prevToken && prevToken.type == AddressTokenTypes.STRING) {
                             // ie. for "%C, %S %Z" without S -> "City, 95100"
                             // Comment this if we want "City 95100" instead
                             // (use the separator between S Z instead of C S)
                             stringToken = prevToken;
                         }
                     }
-                    if (
-                        !ignoreEmptyLines ||
-                        (hasPreviousData && hasData) ||
-                        (index - 1 == firstIndex && hasData)
-                    ) {
+                    if (!ignoreEmptyLines || hasPreviousData && hasData || index - 1 == firstIndex && hasData) {
                         parts.push(stringToken.string);
                     }
                 }
@@ -938,12 +966,8 @@ function formatLineTokens(
             // Output next string only if it is the last
             // and there is previous data before it
             if (index + 1 == lastIndex) {
-                var _stringToken = tokens[index + 1];
-                if (
-                    _stringToken &&
-                    _stringToken.type == AddressTokenTypes.STRING &&
-                    _stringToken.string
-                ) {
+                let _stringToken = tokens[index + 1];
+                if (_stringToken && _stringToken.type == AddressTokenTypes.STRING && _stringToken.string) {
                     if (!ignoreEmptyLines || hasData || hasPreviousData) {
                         parts.push(_stringToken.string);
                     }
@@ -951,68 +975,58 @@ function formatLineTokens(
                 // Consume the last string token
                 index = index + 1;
             }
-        } else {
-            // We should not get here
-        }
+        } else ;
     }
     return parts.join('').trim();
 }
 
 /**
- * Tokenize address format pattern.
- *
- * @param {AddressToken[]} tokens
- * @param {*} data
- * @param {string} lineBreak
- * @param {boolean} ignoreEmptyLines
- * @return {string} Formatted Address
- *
- * @private
- */
+     * Tokenize address format pattern.
+     *
+     * @param {AddressToken[]} tokens
+     * @param {*} data
+     * @param {string} lineBreak
+     * @param {boolean} ignoreEmptyLines
+     * @return {string} Formatted Address
+     *
+     * @private
+     */
 function formatTokens(tokens, data, lineBreak, ignoreEmptyLines) {
-    var lines = [];
-    var lineIndex = -1;
-    for (var index = 0; index < tokens.length; index++) {
-        var doFormat = false;
-        var endWithNewLine = false;
-        var token = tokens[index];
+    let lines = [];
+    let lineIndex = -1;
+    for (let index = 0; index < tokens.length; index++) {
+        let doFormat = false;
+        let endWithNewLine = false;
+        let token = tokens[index];
         switch (token.type) {
-            case AddressTokenTypes.NEWLINE: {
-                if (lineIndex >= 0) {
-                    doFormat = true;
-                    endWithNewLine = true;
-                } else if (!ignoreEmptyLines) {
+        case AddressTokenTypes.NEWLINE:
+        {
+            if (lineIndex >= 0) {
+                doFormat = true;
+                endWithNewLine = true;
+            } else if (!ignoreEmptyLines) {
+                lines.push(''); // Empty line
+                // If the pattern ends with a newline
+                if (index + 1 == tokens.length) {
                     lines.push(''); // Empty line
-                    // If the pattern ends with a newline
-                    if (index + 1 == tokens.length) {
-                        lines.push(''); // Empty line
-                    }
                 }
-                break;
-            }
-            default: {
-                lineIndex = lineIndex < 0 ? index : lineIndex;
-                doFormat = index + 1 == tokens.length ? true : doFormat;
-                break;
             }
+            break;
+        }
+        default:
+        {
+            lineIndex = lineIndex < 0 ? index : lineIndex;
+            doFormat = index + 1 == tokens.length ? true : doFormat;
+            break;
+        }
         }
         if (doFormat) {
-            var line = formatLineTokens(
-                tokens,
-                data,
-                ignoreEmptyLines,
-                lineIndex,
-                endWithNewLine ? index - 1 : index
-            );
+            let line = formatLineTokens(tokens, data, ignoreEmptyLines, lineIndex, endWithNewLine ? index - 1 : index);
             if (!ignoreEmptyLines || line) {
                 lines.push(line);
             }
             // If line ends with a newline, and it is the last line on pattern
-            if (
-                !ignoreEmptyLines &&
-                endWithNewLine &&
-                index + 1 == tokens.length
-            ) {
+            if (!ignoreEmptyLines && endWithNewLine && index + 1 == tokens.length) {
                 lines.push('');
             }
             lineIndex = -1;
@@ -1022,29 +1036,28 @@ function formatTokens(tokens, data, lineBreak, ignoreEmptyLines) {
 }
 
 /**
- * Format address data.
- *
- * @param {*} data Address data being processed.
- * @param {string} pattern Address format pattern.
- * @param {string} lineBreak Line break string to use
- * @param {boolean} ignoreEmptyLines Ignore lines that has no or empty data to replace.
- * @return {string} Formatted address.
- */
+     * Format address data.
+     *
+     * @param {*} data Address data being processed.
+     * @param {string} pattern Address format pattern.
+     * @param {string} lineBreak Line break string to use
+     * @param {boolean} ignoreEmptyLines Ignore lines that has no or empty data to replace.
+     * @return {string} Formatted address.
+     */
 function format(data, pattern, lineBreak, ignoreEmptyLines) {
     // TODO: support escapeHtml to match Java class feature parity
     ignoreEmptyLines = ignoreEmptyLines === false ? false : true; // Defaults to false
     lineBreak = lineBreak || '\n'; // Defaults to <br/> or lf
-    var tokens = [];
+    let tokens = [];
     tokenize(new TokenizerState(pattern, 0), tokens);
     return formatTokens(tokens, data, lineBreak, ignoreEmptyLines);
 }
-
-var addressFormatter = { format: format };
-
-var CJK_COUNTRIES = ['CN', 'HK', 'TW', 'JP', 'KR', 'KP'];
-var CJK_LANGUAGES = ['zh', 'ja', 'ko'];
-
-var address = {
+let addressFormatter = {
+    format: format,
+};
+let CJK_COUNTRIES = ['CN', 'HK', 'TW', 'JP', 'KR', 'KP'];
+let CJK_LANGUAGES = ['zh', 'ja', 'ko'];
+let address = {
     /**
      * Gets the globalization for the specified country code.
      * A: Address Lines (2 or 3 lines address)
@@ -1058,21 +1071,17 @@ var address = {
      * @param {string} countryCode Country Code
      * @return {{fmt: string, input: string, require: string}} Format Data
      */
-    getAddressInfoForCountry: function getAddressInfoForCountry(
-        langCode,
-        countryCode
-    ) {
-        var code = this.getCountryFromLocale(langCode, countryCode);
+    getAddressInfoForCountry: function getAddressInfoForCountry(langCode, countryCode) {
+        let code = this.getCountryFromLocale(langCode, countryCode);
         if (data[code]) {
-            // Double check.
-            var cloneAddressRep = Object.freeze(Object.assign({}, data[code]));
+        // Double check.
+            let cloneAddressRep = Object.freeze(Object.assign({}, data[code]));
             return Object.freeze({
                 address: cloneAddressRep,
             });
         }
         return {};
     },
-
     /**
      * Get the format pattern.
      * A: Address Lines (2 or 3 lines address)
@@ -1087,14 +1096,13 @@ var address = {
      * @return {string} Address Format Pattern
      */
     getAddressFormat: function getAddressFormat(langCode, countryCode) {
-        var code = this.getCountryFromLocale(langCode, countryCode);
+        let code = this.getCountryFromLocale(langCode, countryCode);
         if (data[code]) {
-            // Double check.
+        // Double check.
             return data[code].fmt;
         }
         return '';
     },
-
     /**
      * Get the input order pattern.
      * A: Address Lines (2 or 3 lines address)
@@ -1112,23 +1120,17 @@ var address = {
         // A special case to deal with en_HK locale. We want to use US like
         // format for en_HK.
         // See W-4718344
-        if (
-            langCode &&
-            langCode.toLowerCase() == 'en' &&
-            countryCode &&
-            countryCode.toUpperCase() == 'HK'
-        ) {
+        if (langCode && langCode.toLowerCase() == 'en' && countryCode && countryCode.toUpperCase() == 'HK') {
             langCode = 'en';
             countryCode = 'US';
         }
-        var code = this.getCountryFromLocale(langCode, countryCode);
+        let code = this.getCountryFromLocale(langCode, countryCode);
         if (data[code]) {
-            // Double check.
+        // Double check.
             return data[code].input;
         }
         return '';
     },
-
     /**
      * Get the input order pattern for all fields.
      * A: Address Lines (2 or 3 lines address)
@@ -1142,26 +1144,19 @@ var address = {
      * @param {string} countryCode Country Code
      * @return {string} Input Order
      */
-    getAddressInputOrderAllField: function getAddressInputOrderAllField(
-        langCode,
-        countryCode
-    ) {
+    getAddressInputOrderAllField: function getAddressInputOrderAllField(langCode, countryCode) {
         // A special case to deal with en_HK locale. We want to use US like
         // format for en_HK.
         // See W-4718344
-        if (
-            langCode &&
-            langCode.toLowerCase() == 'en' &&
-            countryCode &&
-            countryCode.toUpperCase() == 'HK'
-        ) {
+        if (langCode && langCode.toLowerCase() == 'en' && countryCode && countryCode.toUpperCase() == 'HK') {
             langCode = 'en';
             countryCode = 'US';
         }
-        var code = this.getCountryFromLocale(langCode, countryCode);
+
+        // Double check.
+        let code = this.getCountryFromLocale(langCode, countryCode);
         if (data[code]) {
-            // Double check.
-            var input = data[code].input;
+            let input = data[code].input;
 
             // Add missing patterns.
             if (input.indexOf('S') === -1) {
@@ -1173,12 +1168,10 @@ var address = {
             if (input.indexOf('Z') === -1) {
                 input = input.replace('C', 'ZC');
             }
-
             return input;
         }
         return '';
     },
-
     /**
      * Get required fields.
      * A: Address Lines (2 or 3 lines address)
@@ -1192,18 +1185,14 @@ var address = {
      * @param {string} countryCode Country Code
      * @return {string} Required Fields
      */
-    getAddressRequireFields: function getAddressRequireFields(
-        langCode,
-        countryCode
-    ) {
-        var code = this.getCountryFromLocale(langCode, countryCode);
+    getAddressRequireFields: function getAddressRequireFields(langCode, countryCode) {
+        let code = this.getCountryFromLocale(langCode, countryCode);
         if (data[code]) {
-            // Double check.
+        // Double check.
             return data[code].require;
         }
         return '';
     },
-
     /**
      * Format a address values for given language code and country code with specified line break.
      *
@@ -1213,16 +1202,11 @@ var address = {
      * @param {string} lineBreak Line Break
      * @return {string} Formatted Address
      */
-    formatAddressAllFields: function formatAddressAllFields(
-        langCode,
-        countryCode,
-        values,
-        lineBreak
-    ) {
-        var code = this.getCountryFromLocale(langCode, countryCode, values);
+    formatAddressAllFields: function formatAddressAllFields(langCode, countryCode, values, lineBreak) {
+        let code = this.getCountryFromLocale(langCode, countryCode, values);
         if (data[code]) {
-            // Double check.
-            var pattern = data[code].fmt;
+        // Double check.
+            let pattern = data[code].fmt;
             // Some countries don't have City, State or ZIP code. We don't want to
             // lose those data from formatted string.
             if (values.zipCode && pattern.indexOf('%Z') === -1) {
@@ -1238,7 +1222,6 @@ var address = {
         }
         return '';
     },
-
     /**
      * Format a address values for given language code and country code with specified line break.
      *
@@ -1248,25 +1231,14 @@ var address = {
      * @param {string} lineBreak Line Break
      * @return {string} Formatted Address
      */
-    formatAddress: function formatAddress(
-        langCode,
-        countryCode,
-        values,
-        lineBreak
-    ) {
-        var code = this.getCountryFromLocale(langCode, countryCode, values);
+    formatAddress: function formatAddress(langCode, countryCode, values, lineBreak) {
+        let code = this.getCountryFromLocale(langCode, countryCode, values);
         if (data[code]) {
-            // Double check.
-            return this.buildAddressLines(
-                data[code].fmt,
-                values,
-                lineBreak,
-                true
-            );
+        // Double check.
+            return this.buildAddressLines(data[code].fmt, values, lineBreak, true);
         }
         return '';
     },
-
     /**
      * Creates an array of address lines given the format and the values to use.
      *
@@ -1276,33 +1248,21 @@ var address = {
      * @param {string} ignoreEmptyLines
      * @return {string} the text for use in the address
      */
-    buildAddressLines: function buildAddressLines(
-        pattern,
-        values,
-        lineBreak,
-        ignoreEmptyLines
-    ) {
-        return addressFormatter.format(
-            values,
-            pattern,
-            lineBreak,
-            ignoreEmptyLines
-        );
+    buildAddressLines: function buildAddressLines(pattern, values, lineBreak, ignoreEmptyLines) {
+        return addressFormatter.format(values, pattern, lineBreak, ignoreEmptyLines);
     },
-
     /**
      * Resolve the reference by tracing down the _ref value.
      * @param {*} data Address Format Data
      * @param {string} countryCode Country Code
      * @return {*} Referenced Address Format Data
      */
-    followReferences: function followReferences(data$$1, countryCode) {
-        if (data$$1[countryCode] && data$$1[countryCode]._ref) {
-            return this.followReferences(data$$1, data$$1[countryCode]._ref);
+    followReferences: function followReferences(data, countryCode) {
+        if (data[countryCode] && data[countryCode]._ref) {
+            return this.followReferences(data, data[countryCode]._ref);
         }
         return countryCode;
     },
-
     /**
      * Check strings for Han characters
      *
@@ -1310,14 +1270,9 @@ var address = {
      * @return {boolean} true if any of string values contain Han script character
      */
     containsHanScript: function containsHanScript() {
-        for (
-            var _len = arguments.length, values = Array(_len), _key = 0;
-            _key < _len;
-            _key++
-        ) {
+        for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
             values[_key] = arguments[_key];
         }
-
         if (!values || !Array.isArray(values)) return false;
         return values.some(function(value) {
             if (!value) return false;
@@ -1325,77 +1280,86 @@ var address = {
             // Iterating a string returns a char that contains one codepoint.
             // Surrogate pairs will be returned as a pair.
             // Unicode block ranges: @see http://www.unicode.org/Public/UCD/latest/ucd/Blocks.txt
-            var _iteratorNormalCompletion = true;
-            var _didIteratorError = false;
-            var _iteratorError = undefined;
-
+            let _iterator = _createForOfIteratorHelper(value);
+            let _step;
             try {
-                for (
-                    var _iterator = value[Symbol.iterator](), _step;
-                    !(_iteratorNormalCompletion = (_step = _iterator.next())
-                        .done);
-                    _iteratorNormalCompletion = true
-                ) {
-                    var singleChar = _step.value;
-
-                    var codePoint = singleChar.codePointAt(0); // Thank you ES2015
-                    if (
-                        (0x2e80 <= codePoint && codePoint <= 0x2eff) || // CJK Radicals Supplement
-                        (0x3300 <= codePoint && codePoint <= 0x33ff) || // CJK Compatibility
-                        (0xfe30 <= codePoint && codePoint <= 0xfe4f) || // CJK Compatibility Forms
-                        (0xf900 <= codePoint && codePoint <= 0xfaff) || // CJK Compatibility Ideographs
-                        (0x2f800 <= codePoint && codePoint <= 0x2fa1f) || // CJK Compatibility Ideographs Supplement
-                        (0x3000 <= codePoint && codePoint <= 0x303f) || // CJK Symbols and Punctuation
-                        (0x4e00 <= codePoint && codePoint <= 0x9fff) || // CJK Unified Ideographs
-                        (0x3400 <= codePoint && codePoint <= 0x4dbf) || // CJK Unified Ideographs Extension A
-                        (0x20000 <= codePoint && codePoint <= 0x2a6df) || // CJK Unified Ideographs Extension B
-                        (0x2a700 <= codePoint && codePoint <= 0x2b73f) || // CJK Unified Ideographs Extension C
-                        (0x2b740 <= codePoint && codePoint <= 0x2b81f) || // CJK Unified Ideographs Extension D
-                        (0x2b820 <= codePoint && codePoint <= 0x2ceaf) || // CJK Unified Ideographs Extension E // Not on core
-                        (0x2ceb0 <= codePoint && codePoint <= 0x2ebef) || // CJK Unified Ideographs Extension F // Not on core
-                        (0x3200 <= codePoint && codePoint <= 0x32ff) || // Enclosed CJK Letters and Months
-                        (0x31c0 <= codePoint && codePoint <= 0x31ef) || // CJK Strokes
-                        // Chinese
-                        (0x3100 <= codePoint && codePoint <= 0x312f) || // Bopomofo
-                        (0x31a0 <= codePoint && codePoint <= 0x31bf) || // Bopomofo Extended
-                        (0x2f00 <= codePoint && codePoint <= 0x2fdf) || // Kangxi Radicals
-                        (0x2ff0 <= codePoint && codePoint <= 0x2fff) || // Ideographic Description Characters
-                        // Japanese
-                        (0xff00 <= codePoint && codePoint <= 0xffef) || // Halfwidth and Fullwidth Forms
-                        (0x3040 <= codePoint && codePoint <= 0x309f) || // Hiragana
-                        (0x30a0 <= codePoint && codePoint <= 0x30ff) || // Katakana
-                        (0x31f0 <= codePoint && codePoint <= 0x31ff) || // Katakana Phonetic Extensions
-                        (0x1b000 <= codePoint && codePoint <= 0x1b0ff) || // Kana Supplement
-                        (0x1b100 <= codePoint && codePoint <= 0x1b12f) || // Kana Extended-A // Not on core
-                        // Korean
-                        (0x1100 <= codePoint && codePoint <= 0x11ff) || // Hangul Jamo
-                        (0xac00 <= codePoint && codePoint <= 0xd7af) || // Hangul Syllables
-                        (0x3130 <= codePoint && codePoint <= 0x318f) || // Hangul Compatibility Jamo
-                        (0xa960 <= codePoint && codePoint <= 0xa97f) || // Hangul Jamo Extended-A
-                        (0xd7b0 <= codePoint && codePoint <= 0xd7ff) // Hangul Jamo Extended-B
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    let singleChar = _step.value;
+                    let codePoint = singleChar.codePointAt(0); // Thank you ES2015
+                    if (0x2e80 <= codePoint && codePoint <= 0x2eff ||
+            // CJK Radicals Supplement
+            0x3300 <= codePoint && codePoint <= 0x33ff ||
+            // CJK Compatibility
+            0xfe30 <= codePoint && codePoint <= 0xfe4f ||
+            // CJK Compatibility Forms
+            0xf900 <= codePoint && codePoint <= 0xfaff ||
+            // CJK Compatibility Ideographs
+            0x2f800 <= codePoint && codePoint <= 0x2fa1f ||
+            // CJK Compatibility Ideographs Supplement
+            0x3000 <= codePoint && codePoint <= 0x303f ||
+            // CJK Symbols and Punctuation
+            0x4e00 <= codePoint && codePoint <= 0x9fff ||
+            // CJK Unified Ideographs
+            0x3400 <= codePoint && codePoint <= 0x4dbf ||
+            // CJK Unified Ideographs Extension A
+            0x20000 <= codePoint && codePoint <= 0x2a6df ||
+            // CJK Unified Ideographs Extension B
+            0x2a700 <= codePoint && codePoint <= 0x2b73f ||
+            // CJK Unified Ideographs Extension C
+            0x2b740 <= codePoint && codePoint <= 0x2b81f ||
+            // CJK Unified Ideographs Extension D
+            0x2b820 <= codePoint && codePoint <= 0x2ceaf ||
+            // CJK Unified Ideographs Extension E // Not on core
+            0x2ceb0 <= codePoint && codePoint <= 0x2ebef ||
+            // CJK Unified Ideographs Extension F // Not on core
+            0x3200 <= codePoint && codePoint <= 0x32ff ||
+            // Enclosed CJK Letters and Months
+            0x31c0 <= codePoint && codePoint <= 0x31ef ||
+            // CJK Strokes
+            // Chinese
+            0x3100 <= codePoint && codePoint <= 0x312f ||
+            // Bopomofo
+            0x31a0 <= codePoint && codePoint <= 0x31bf ||
+            // Bopomofo Extended
+            0x2f00 <= codePoint && codePoint <= 0x2fdf ||
+            // Kangxi Radicals
+            0x2ff0 <= codePoint && codePoint <= 0x2fff ||
+            // Ideographic Description Characters
+            // Japanese
+            0xff00 <= codePoint && codePoint <= 0xffef ||
+            // Halfwidth and Fullwidth Forms
+            0x3040 <= codePoint && codePoint <= 0x309f ||
+            // Hiragana
+            0x30a0 <= codePoint && codePoint <= 0x30ff ||
+            // Katakana
+            0x31f0 <= codePoint && codePoint <= 0x31ff ||
+            // Katakana Phonetic Extensions
+            0x1b000 <= codePoint && codePoint <= 0x1b0ff ||
+            // Kana Supplement
+            0x1b100 <= codePoint && codePoint <= 0x1b12f ||
+            // Kana Extended-A // Not on core
+            // Korean
+            0x1100 <= codePoint && codePoint <= 0x11ff ||
+            // Hangul Jamo
+            0xac00 <= codePoint && codePoint <= 0xd7af ||
+            // Hangul Syllables
+            0x3130 <= codePoint && codePoint <= 0x318f ||
+            // Hangul Compatibility Jamo
+            0xa960 <= codePoint && codePoint <= 0xa97f ||
+            // Hangul Jamo Extended-A
+            0xd7b0 <= codePoint && codePoint <= 0xd7ff // Hangul Jamo Extended-B
                     ) {
                         return true;
                     }
                 }
             } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
+                _iterator.e(err);
             } finally {
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return) {
-                        _iterator.return();
-                    }
-                } finally {
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
+                _iterator.f();
             }
-
             return false;
         });
     },
-
     /**
      * Returns the address code (country code) for given locale and data.
      *
@@ -1404,57 +1368,36 @@ var address = {
      * @param {*} values Address Data
      * @return {string} Address Code
      */
-    getCountryFromLocale: function getCountryFromLocale(
-        langCode,
-        countryCode,
-        values
-    ) {
+    getCountryFromLocale: function getCountryFromLocale(langCode, countryCode, values) {
         if (values) {
-            var isCJK =
-                (!countryCode &&
-                    CJK_LANGUAGES.indexOf(langCode.toLowerCase()) >= 0) ||
-                (countryCode &&
-                    CJK_COUNTRIES.indexOf(countryCode.toUpperCase()) >= 0);
-            var isJA =
-                (!countryCode && 'ja' == langCode.toLowerCase()) ||
-                (countryCode && 'JP' == countryCode.toUpperCase());
+            let isCJK = !countryCode && CJK_LANGUAGES.indexOf(langCode.toLowerCase()) >= 0 || countryCode && CJK_COUNTRIES.indexOf(countryCode.toUpperCase()) >= 0;
+            let isJA = !countryCode && 'ja' == langCode.toLowerCase() || countryCode && 'JP' == countryCode.toUpperCase();
+
             // English format (ja_en_JP) is only used when all fields do not contain CJK characters
-            if (
-                !(
-                    isJA &&
-                    this.containsHanScript(
-                        values.address,
-                        values.city,
-                        values.state,
-                        values.country
-                    )
-                ) &&
-                isCJK &&
-                !this.containsHanScript(values.address)
-            ) {
+            if (!(isJA && this.containsHanScript(values.address, values.city, values.state, values.country)) && isCJK && !this.containsHanScript(values.address)) {
                 return this.getCountryFromLocale(langCode, 'EN_' + countryCode);
             }
         }
-
-        var country = countryCode;
+        let country = countryCode;
+        // hack for 'uz_Latn_UZ'. caller may pass 'Latn' as countryCode. override with 'UZ' here.
+        if (langCode == 'uz' && country && country.toLowerCase() == 'latn') {
+            country = 'UZ';
+        }
 
         // Address format should be always associated to a COUNTRY.
         // If country part is empty, we need to map language to a
-        // certain country. For example, "de" -> "DE".
-        if (!countryCode && languageCodeToCountry.languageCode[langCode]) {
+        // certain country. For example, "de" -> "DE".da
+        if (!country && languageCodeToCountry.languageCode[langCode]) {
             country = languageCodeToCountry.languageCode[langCode];
         }
 
         // Trace the real data from country reference.
         country = this.followReferences(data, country);
-
         if (!country || !data[country]) {
             return 'US'; // Always fall back to US format.
         }
-
         return country;
     },
-
     /**
      * Get fall back country code.
      *