| // Copyright (C) 2011 2012 Norbert Lindenberg. All rights reserved. |
| // Copyright (C) 2012 2013 Mozilla Corporation. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| /*--- |
| description: | |
| This file contains shared functions for the tests in the conformance test |
| suite for the ECMAScript Internationalization API. |
| author: Norbert Lindenberg |
| defines: |
| - testWithIntlConstructors |
| - taintDataProperty |
| - taintMethod |
| - taintProperties |
| - taintArray |
| - getLocaleSupportInfo |
| - getInvalidLanguageTags |
| - isCanonicalizedStructurallyValidLanguageTag |
| - getInvalidLocaleArguments |
| - testOption |
| - testForUnwantedRegExpChanges |
| - isValidNumberingSystem |
| - testNumberFormat |
| - getDateTimeComponents |
| - getDateTimeComponentValues |
| - isCanonicalizedStructurallyValidTimeZoneName |
| ---*/ |
| /** |
| */ |
| |
| |
| /** |
| * @description Calls the provided function for every service constructor in |
| * the Intl object. |
| * @param {Function} f the function to call for each service constructor in |
| * the Intl object. |
| * @param {Function} Constructor the constructor object to test with. |
| */ |
| function testWithIntlConstructors(f) { |
| var constructors = ["Collator", "NumberFormat", "DateTimeFormat"]; |
| |
| // Optionally supported Intl constructors. |
| ["PluralRules"].forEach(function(constructor) { |
| if (typeof Intl[constructor] === "function") { |
| constructors[constructors.length] = constructor; |
| } |
| }); |
| |
| constructors.forEach(function (constructor) { |
| var Constructor = Intl[constructor]; |
| try { |
| f(Constructor); |
| } catch (e) { |
| e.message += " (Testing with " + constructor + ".)"; |
| throw e; |
| } |
| }); |
| } |
| |
| |
| /** |
| * Taints a named data property of the given object by installing |
| * a setter that throws an exception. |
| * @param {object} obj the object whose data property to taint |
| * @param {string} property the property to taint |
| */ |
| function taintDataProperty(obj, property) { |
| Object.defineProperty(obj, property, { |
| set: function(value) { |
| $ERROR("Client code can adversely affect behavior: setter for " + property + "."); |
| }, |
| enumerable: false, |
| configurable: true |
| }); |
| } |
| |
| |
| /** |
| * Taints a named method of the given object by replacing it with a function |
| * that throws an exception. |
| * @param {object} obj the object whose method to taint |
| * @param {string} property the name of the method to taint |
| */ |
| function taintMethod(obj, property) { |
| Object.defineProperty(obj, property, { |
| value: function() { |
| $ERROR("Client code can adversely affect behavior: method " + property + "."); |
| }, |
| writable: true, |
| enumerable: false, |
| configurable: true |
| }); |
| } |
| |
| |
| /** |
| * Taints the given properties (and similarly named properties) by installing |
| * setters on Object.prototype that throw exceptions. |
| * @param {Array} properties an array of property names to taint |
| */ |
| function taintProperties(properties) { |
| properties.forEach(function (property) { |
| var adaptedProperties = [property, "__" + property, "_" + property, property + "_", property + "__"]; |
| adaptedProperties.forEach(function (property) { |
| taintDataProperty(Object.prototype, property); |
| }); |
| }); |
| } |
| |
| |
| /** |
| * Taints the Array object by creating a setter for the property "0" and |
| * replacing some key methods with functions that throw exceptions. |
| */ |
| function taintArray() { |
| taintDataProperty(Array.prototype, "0"); |
| taintMethod(Array.prototype, "indexOf"); |
| taintMethod(Array.prototype, "join"); |
| taintMethod(Array.prototype, "push"); |
| taintMethod(Array.prototype, "slice"); |
| taintMethod(Array.prototype, "sort"); |
| } |
| |
| |
| /** |
| * Gets locale support info for the given constructor object, which must be one |
| * of Intl constructors. |
| * @param {object} Constructor the constructor for which to get locale support info |
| * @return {object} locale support info with the following properties: |
| * supported: array of fully supported language tags |
| * byFallback: array of language tags that are supported through fallbacks |
| * unsupported: array of unsupported language tags |
| */ |
| function getLocaleSupportInfo(Constructor) { |
| var languages = ["zh", "es", "en", "hi", "ur", "ar", "ja", "pa"]; |
| var scripts = ["Latn", "Hans", "Deva", "Arab", "Jpan", "Hant", "Guru"]; |
| var countries = ["CN", "IN", "US", "PK", "JP", "TW", "HK", "SG", "419"]; |
| |
| var allTags = []; |
| var i, j, k; |
| var language, script, country; |
| for (i = 0; i < languages.length; i++) { |
| language = languages[i]; |
| allTags.push(language); |
| for (j = 0; j < scripts.length; j++) { |
| script = scripts[j]; |
| allTags.push(language + "-" + script); |
| for (k = 0; k < countries.length; k++) { |
| country = countries[k]; |
| allTags.push(language + "-" + script + "-" + country); |
| } |
| } |
| for (k = 0; k < countries.length; k++) { |
| country = countries[k]; |
| allTags.push(language + "-" + country); |
| } |
| } |
| |
| var supported = []; |
| var byFallback = []; |
| var unsupported = []; |
| for (i = 0; i < allTags.length; i++) { |
| var request = allTags[i]; |
| var result = new Constructor([request], {localeMatcher: "lookup"}).resolvedOptions().locale; |
| if (request === result) { |
| supported.push(request); |
| } else if (request.indexOf(result) === 0) { |
| byFallback.push(request); |
| } else { |
| unsupported.push(request); |
| } |
| } |
| |
| return { |
| supported: supported, |
| byFallback: byFallback, |
| unsupported: unsupported |
| }; |
| } |
| |
| |
| /** |
| * Returns an array of strings for which IsStructurallyValidLanguageTag() returns false |
| */ |
| function getInvalidLanguageTags() { |
| var invalidLanguageTags = [ |
| "", // empty tag |
| "i", // singleton alone |
| "x", // private use without subtag |
| "u", // extension singleton in first place |
| "419", // region code in first place |
| "u-nu-latn-cu-bob", // extension sequence without language |
| "hans-cmn-cn", // "hans" could theoretically be a 4-letter language code, |
| // but those can't be followed by extlang codes. |
| "cmn-hans-cn-u-u", // duplicate singleton |
| "cmn-hans-cn-t-u-ca-u", // duplicate singleton |
| "de-gregory-gregory", // duplicate variant |
| "*", // language range |
| "de-*", // language range |
| "中文", // non-ASCII letters |
| "en-ß", // non-ASCII letters |
| "ıd", // non-ASCII letters |
| "es-Latn-latn", // two scripts |
| "pl-PL-pl", // two regions |
| "u-ca-gregory", // extension in first place |
| "de-1996-1996", // duplicate numeric variant |
| "pt-u-ca-gregory-u-nu-latn", // duplicate singleton subtag |
| |
| // Invalid tags starting with: https://github.com/tc39/ecma402/pull/289 |
| "no-nyn", // regular grandfathered in BCP47, but invalid in UTS35 |
| "i-klingon", // irregular grandfathered in BCP47, but invalid in UTS35 |
| "zh-hak-CN", // language with extlang in BCP47, but invalid in UTS35 |
| "sgn-ils", // language with extlang in BCP47, but invalid in UTS35 |
| "x-foo", // privateuse-only in BCP47, but invalid in UTS35 |
| "x-en-US-12345", // more privateuse-only variants. |
| "x-12345-12345-en-US", |
| "x-en-US-12345-12345", |
| "x-en-u-foo", |
| "x-en-u-foo-u-bar", |
| "x-u-foo", |
| |
| // underscores in different parts of the language tag |
| "de_DE", |
| "DE_de", |
| "cmn_Hans", |
| "cmn-hans_cn", |
| "es_419", |
| "es-419-u-nu-latn-cu_bob", |
| "i_klingon", |
| "cmn-hans-cn-t-ca-u-ca-x_t-u", |
| "enochian_enochian", |
| "de-gregory_u-ca-gregory", |
| |
| "en\u0000", // null-terminator sequence |
| " en", // leading whitespace |
| "en ", // trailing whitespace |
| "it-IT-Latn", // country before script tag |
| "de-u", // incomplete Unicode extension sequences |
| "de-u-", |
| "de-u-ca-", |
| "de-u-ca-gregory-", |
| "si-x", // incomplete private-use tags |
| "x-", |
| "x-y-", |
| ]; |
| |
| // make sure the data above is correct |
| for (var i = 0; i < invalidLanguageTags.length; ++i) { |
| var invalidTag = invalidLanguageTags[i]; |
| assert( |
| !isCanonicalizedStructurallyValidLanguageTag(invalidTag), |
| "Test data \"" + invalidTag + "\" is a canonicalized and structurally valid language tag." |
| ); |
| } |
| |
| return invalidLanguageTags; |
| } |
| |
| |
| /** |
| * @description Tests whether locale is a String value representing a |
| * structurally valid and canonicalized BCP 47 language tag, as defined in |
| * sections 6.2.2 and 6.2.3 of the ECMAScript Internationalization API |
| * Specification. |
| * @param {String} locale the string to be tested. |
| * @result {Boolean} whether the test succeeded. |
| */ |
| function isCanonicalizedStructurallyValidLanguageTag(locale) { |
| |
| /** |
| * Regular expression defining Unicode BCP 47 Locale Identifiers. |
| * |
| * Spec: https://unicode.org/reports/tr35/#Unicode_locale_identifier |
| */ |
| var alpha = "[a-z]", |
| digit = "[0-9]", |
| alphanum = "(" + alpha + "|" + digit + ")", |
| variant = "(" + alphanum + "{5,8}|(" + digit + alphanum + "{3}))", |
| region = "(" + alpha + "{2}|" + digit + "{3})", |
| script = "(" + alpha + "{4})", |
| language = "(" + alpha + "{2,3}|" + alpha + "{5,8})", |
| privateuse = "(x(-[a-z0-9]{1,8})+)", |
| singleton = "(" + digit + "|[a-wy-z])", |
| attribute= "(" + alphanum + "{3,8})", |
| keyword = "(" + alphanum + alpha + "(-" + alphanum + "{3,8})*)", |
| unicode_locale_extensions = "(u((-" + keyword + ")+|((-" + attribute + ")+(-" + keyword + ")*)))", |
| tlang = "(" + language + "(-" + script + ")?(-" + region + ")?(-" + variant + ")*)", |
| tfield = "(" + alpha + digit + "(-" + alphanum + "{3,8})+)", |
| transformed_extensions = "(t((-" + tlang + "(-" + tfield + ")*)|(-" + tfield + ")+))", |
| other_singleton = "(" + digit + "|[a-sv-wy-z])", |
| other_extensions = "(" + other_singleton + "(-" + alphanum + "{2,8})+)", |
| extension = "(" + unicode_locale_extensions + "|" + transformed_extensions + "|" + other_extensions + ")", |
| locale_id = language + "(-" + script + ")?(-" + region + ")?(-" + variant + ")*(-" + extension + ")*(-" + privateuse + ")?", |
| languageTag = "^(" + locale_id + ")$", |
| languageTagRE = new RegExp(languageTag, "i"); |
| |
| var duplicateSingleton = "-" + singleton + "-(.*-)?\\1(?!" + alphanum + ")", |
| duplicateSingletonRE = new RegExp(duplicateSingleton, "i"), |
| duplicateVariant = "(" + alphanum + "{2,8}-)+" + variant + "-(" + alphanum + "{2,8}-)*\\3(?!" + alphanum + ")", |
| duplicateVariantRE = new RegExp(duplicateVariant, "i"); |
| |
| |
| /** |
| * Verifies that the given string is a well-formed Unicode BCP 47 Locale Identifier |
| * with no duplicate variant or singleton subtags. |
| * |
| * Spec: ECMAScript Internationalization API Specification, draft, 6.2.2. |
| */ |
| function isStructurallyValidLanguageTag(locale) { |
| if (!languageTagRE.test(locale)) { |
| return false; |
| } |
| locale = locale.split(/-x-/)[0]; |
| return !duplicateSingletonRE.test(locale) && !duplicateVariantRE.test(locale); |
| } |
| |
| |
| /** |
| * Mappings from complete tags to preferred values. |
| * |
| * Spec: http://unicode.org/reports/tr35/#Identifiers |
| * Version: CLDR, version 35 |
| */ |
| var __tagMappings = { |
| // property names must be in lower case; values in canonical form |
| |
| "art-lojban": "jbo", |
| "cel-gaulish": "xtg-x-cel-gaulish", |
| "zh-guoyu": "zh", |
| "zh-hakka": "hak", |
| "zh-xiang": "hsn", |
| }; |
| |
| |
| /** |
| * Mappings from language subtags to preferred values. |
| * |
| * Spec: http://unicode.org/reports/tr35/#Identifiers |
| * Version: CLDR, version 35 |
| */ |
| var __languageMappings = { |
| // property names and values must be in canonical case |
| |
| "aam": "aas", |
| "aar": "aa", |
| "abk": "ab", |
| "adp": "dz", |
| "afr": "af", |
| "aju": "jrb", |
| "aka": "ak", |
| "alb": "sq", |
| "als": "sq", |
| "amh": "am", |
| "ara": "ar", |
| "arb": "ar", |
| "arg": "an", |
| "arm": "hy", |
| "asm": "as", |
| "aue": "ktz", |
| "ava": "av", |
| "ave": "ae", |
| "aym": "ay", |
| "ayr": "ay", |
| "ayx": "nun", |
| "aze": "az", |
| "azj": "az", |
| "bak": "ba", |
| "bam": "bm", |
| "baq": "eu", |
| "bcc": "bal", |
| "bcl": "bik", |
| "bel": "be", |
| "ben": "bn", |
| "bgm": "bcg", |
| "bh": "bho", |
| "bih": "bho", |
| "bis": "bi", |
| "bjd": "drl", |
| "bod": "bo", |
| "bos": "bs", |
| "bre": "br", |
| "bul": "bg", |
| "bur": "my", |
| "bxk": "luy", |
| "bxr": "bua", |
| "cat": "ca", |
| "ccq": "rki", |
| "ces": "cs", |
| "cha": "ch", |
| "che": "ce", |
| "chi": "zh", |
| "chu": "cu", |
| "chv": "cv", |
| "cjr": "mom", |
| "cka": "cmr", |
| "cld": "syr", |
| "cmk": "xch", |
| "cmn": "zh", |
| "cor": "kw", |
| "cos": "co", |
| "coy": "pij", |
| "cqu": "quh", |
| "cre": "cr", |
| "cwd": "cr", |
| "cym": "cy", |
| "cze": "cs", |
| "dan": "da", |
| "deu": "de", |
| "dgo": "doi", |
| "dhd": "mwr", |
| "dik": "din", |
| "diq": "zza", |
| "div": "dv", |
| "drh": "mn", |
| "dut": "nl", |
| "dzo": "dz", |
| "ekk": "et", |
| "ell": "el", |
| "emk": "man", |
| "eng": "en", |
| "epo": "eo", |
| "esk": "ik", |
| "est": "et", |
| "eus": "eu", |
| "ewe": "ee", |
| "fao": "fo", |
| "fas": "fa", |
| "fat": "ak", |
| "fij": "fj", |
| "fin": "fi", |
| "fra": "fr", |
| "fre": "fr", |
| "fry": "fy", |
| "fuc": "ff", |
| "ful": "ff", |
| "gav": "dev", |
| "gaz": "om", |
| "gbo": "grb", |
| "geo": "ka", |
| "ger": "de", |
| "gfx": "vaj", |
| "ggn": "gvr", |
| "gla": "gd", |
| "gle": "ga", |
| "glg": "gl", |
| "glv": "gv", |
| "gno": "gon", |
| "gre": "el", |
| "grn": "gn", |
| "gti": "nyc", |
| "gug": "gn", |
| "guj": "gu", |
| "guv": "duz", |
| "gya": "gba", |
| "hat": "ht", |
| "hau": "ha", |
| "hdn": "hai", |
| "hea": "hmn", |
| "heb": "he", |
| "her": "hz", |
| "him": "srx", |
| "hin": "hi", |
| "hmo": "ho", |
| "hrr": "jal", |
| "hrv": "hr", |
| "hun": "hu", |
| "hye": "hy", |
| "ibi": "opa", |
| "ibo": "ig", |
| "ice": "is", |
| "ido": "io", |
| "iii": "ii", |
| "ike": "iu", |
| "iku": "iu", |
| "ile": "ie", |
| "ilw": "gal", |
| "in": "id", |
| "ina": "ia", |
| "ind": "id", |
| "ipk": "ik", |
| "isl": "is", |
| "ita": "it", |
| "iw": "he", |
| "jav": "jv", |
| "jeg": "oyb", |
| "ji": "yi", |
| "jpn": "ja", |
| "jw": "jv", |
| "kal": "kl", |
| "kan": "kn", |
| "kas": "ks", |
| "kat": "ka", |
| "kau": "kr", |
| "kaz": "kk", |
| "kgc": "tdf", |
| "kgh": "kml", |
| "khk": "mn", |
| "khm": "km", |
| "kik": "ki", |
| "kin": "rw", |
| "kir": "ky", |
| "kmr": "ku", |
| "knc": "kr", |
| "kng": "kg", |
| "knn": "kok", |
| "koj": "kwv", |
| "kom": "kv", |
| "kon": "kg", |
| "kor": "ko", |
| "kpv": "kv", |
| "krm": "bmf", |
| "ktr": "dtp", |
| "kua": "kj", |
| "kur": "ku", |
| "kvs": "gdj", |
| "kwq": "yam", |
| "kxe": "tvd", |
| "kzj": "dtp", |
| "kzt": "dtp", |
| "lao": "lo", |
| "lat": "la", |
| "lav": "lv", |
| "lbk": "bnc", |
| "lii": "raq", |
| "lim": "li", |
| "lin": "ln", |
| "lit": "lt", |
| "lmm": "rmx", |
| "ltz": "lb", |
| "lub": "lu", |
| "lug": "lg", |
| "lvs": "lv", |
| "mac": "mk", |
| "mah": "mh", |
| "mal": "ml", |
| "mao": "mi", |
| "mar": "mr", |
| "may": "ms", |
| "meg": "cir", |
| "mhr": "chm", |
| "mkd": "mk", |
| "mlg": "mg", |
| "mlt": "mt", |
| "mnk": "man", |
| "mo": "ro", |
| "mol": "ro", |
| "mon": "mn", |
| "mri": "mi", |
| "msa": "ms", |
| "mst": "mry", |
| "mup": "raj", |
| "mwj": "vaj", |
| "mya": "my", |
| "myt": "mry", |
| "nad": "xny", |
| "nau": "na", |
| "nav": "nv", |
| "nbl": "nr", |
| "ncp": "kdz", |
| "nde": "nd", |
| "ndo": "ng", |
| "nep": "ne", |
| "nld": "nl", |
| "nno": "nn", |
| "nnx": "ngv", |
| "no": "nb", |
| "nob": "nb", |
| "nor": "nb", |
| "npi": "ne", |
| "nts": "pij", |
| "nya": "ny", |
| "oci": "oc", |
| "ojg": "oj", |
| "oji": "oj", |
| "ori": "or", |
| "orm": "om", |
| "ory": "or", |
| "oss": "os", |
| "oun": "vaj", |
| "pan": "pa", |
| "pbu": "ps", |
| "pcr": "adx", |
| "per": "fa", |
| "pes": "fa", |
| "pli": "pi", |
| "plt": "mg", |
| "pmc": "huw", |
| "pmu": "phr", |
| "pnb": "lah", |
| "pol": "pl", |
| "por": "pt", |
| "ppa": "bfy", |
| "ppr": "lcq", |
| "pry": "prt", |
| "pus": "ps", |
| "puz": "pub", |
| "que": "qu", |
| "quz": "qu", |
| "rmy": "rom", |
| "roh": "rm", |
| "ron": "ro", |
| "rum": "ro", |
| "run": "rn", |
| "rus": "ru", |
| "sag": "sg", |
| "san": "sa", |
| "sca": "hle", |
| "scc": "sr", |
| "scr": "hr", |
| "sin": "si", |
| "skk": "oyb", |
| "slk": "sk", |
| "slo": "sk", |
| "slv": "sl", |
| "sme": "se", |
| "smo": "sm", |
| "sna": "sn", |
| "snd": "sd", |
| "som": "so", |
| "sot": "st", |
| "spa": "es", |
| "spy": "kln", |
| "sqi": "sq", |
| "src": "sc", |
| "srd": "sc", |
| "srp": "sr", |
| "ssw": "ss", |
| "sun": "su", |
| "swa": "sw", |
| "swe": "sv", |
| "swh": "sw", |
| "tah": "ty", |
| "tam": "ta", |
| "tat": "tt", |
| "tdu": "dtp", |
| "tel": "te", |
| "tgk": "tg", |
| "tgl": "fil", |
| "tha": "th", |
| "thc": "tpo", |
| "thx": "oyb", |
| "tib": "bo", |
| "tie": "ras", |
| "tir": "ti", |
| "tkk": "twm", |
| "tl": "fil", |
| "tlw": "weo", |
| "tmp": "tyj", |
| "tne": "kak", |
| "ton": "to", |
| "tsf": "taj", |
| "tsn": "tn", |
| "tso": "ts", |
| "ttq": "tmh", |
| "tuk": "tk", |
| "tur": "tr", |
| "tw": "ak", |
| "twi": "ak", |
| "uig": "ug", |
| "ukr": "uk", |
| "umu": "del", |
| "uok": "ema", |
| "urd": "ur", |
| "uzb": "uz", |
| "uzn": "uz", |
| "ven": "ve", |
| "vie": "vi", |
| "vol": "vo", |
| "wel": "cy", |
| "wln": "wa", |
| "wol": "wo", |
| "xba": "cax", |
| "xho": "xh", |
| "xia": "acn", |
| "xkh": "waw", |
| "xpe": "kpe", |
| "xsj": "suj", |
| "xsl": "den", |
| "ybd": "rki", |
| "ydd": "yi", |
| "yid": "yi", |
| "yma": "lrr", |
| "ymt": "mtm", |
| "yor": "yo", |
| "yos": "zom", |
| "yuu": "yug", |
| "zai": "zap", |
| "zha": "za", |
| "zho": "zh", |
| "zsm": "ms", |
| "zul": "zu", |
| "zyb": "za", |
| } |
| |
| |
| /** |
| * Mappings from region subtags to preferred values. |
| * |
| * Spec: http://unicode.org/reports/tr35/#Identifiers |
| * Version: CLDR, version 35 |
| */ |
| var __regionMappings = { |
| // property names and values must be in canonical case |
| |
| "004": "AF", |
| "008": "AL", |
| "010": "AQ", |
| "012": "DZ", |
| "016": "AS", |
| "020": "AD", |
| "024": "AO", |
| "028": "AG", |
| "031": "AZ", |
| "032": "AR", |
| "036": "AU", |
| "040": "AT", |
| "044": "BS", |
| "048": "BH", |
| "050": "BD", |
| "051": "AM", |
| "052": "BB", |
| "056": "BE", |
| "060": "BM", |
| "062": "034", |
| "064": "BT", |
| "068": "BO", |
| "070": "BA", |
| "072": "BW", |
| "074": "BV", |
| "076": "BR", |
| "084": "BZ", |
| "086": "IO", |
| "090": "SB", |
| "092": "VG", |
| "096": "BN", |
| "100": "BG", |
| "104": "MM", |
| "108": "BI", |
| "112": "BY", |
| "116": "KH", |
| "120": "CM", |
| "124": "CA", |
| "132": "CV", |
| "136": "KY", |
| "140": "CF", |
| "144": "LK", |
| "148": "TD", |
| "152": "CL", |
| "156": "CN", |
| "158": "TW", |
| "162": "CX", |
| "166": "CC", |
| "170": "CO", |
| "174": "KM", |
| "175": "YT", |
| "178": "CG", |
| "180": "CD", |
| "184": "CK", |
| "188": "CR", |
| "191": "HR", |
| "192": "CU", |
| "196": "CY", |
| "203": "CZ", |
| "204": "BJ", |
| "208": "DK", |
| "212": "DM", |
| "214": "DO", |
| "218": "EC", |
| "222": "SV", |
| "226": "GQ", |
| "230": "ET", |
| "231": "ET", |
| "232": "ER", |
| "233": "EE", |
| "234": "FO", |
| "238": "FK", |
| "239": "GS", |
| "242": "FJ", |
| "246": "FI", |
| "248": "AX", |
| "249": "FR", |
| "250": "FR", |
| "254": "GF", |
| "258": "PF", |
| "260": "TF", |
| "262": "DJ", |
| "266": "GA", |
| "268": "GE", |
| "270": "GM", |
| "275": "PS", |
| "276": "DE", |
| "278": "DE", |
| "280": "DE", |
| "288": "GH", |
| "292": "GI", |
| "296": "KI", |
| "300": "GR", |
| "304": "GL", |
| "308": "GD", |
| "312": "GP", |
| "316": "GU", |
| "320": "GT", |
| "324": "GN", |
| "328": "GY", |
| "332": "HT", |
| "334": "HM", |
| "336": "VA", |
| "340": "HN", |
| "344": "HK", |
| "348": "HU", |
| "352": "IS", |
| "356": "IN", |
| "360": "ID", |
| "364": "IR", |
| "368": "IQ", |
| "372": "IE", |
| "376": "IL", |
| "380": "IT", |
| "384": "CI", |
| "388": "JM", |
| "392": "JP", |
| "398": "KZ", |
| "400": "JO", |
| "404": "KE", |
| "408": "KP", |
| "410": "KR", |
| "414": "KW", |
| "417": "KG", |
| "418": "LA", |
| "422": "LB", |
| "426": "LS", |
| "428": "LV", |
| "430": "LR", |
| "434": "LY", |
| "438": "LI", |
| "440": "LT", |
| "442": "LU", |
| "446": "MO", |
| "450": "MG", |
| "454": "MW", |
| "458": "MY", |
| "462": "MV", |
| "466": "ML", |
| "470": "MT", |
| "474": "MQ", |
| "478": "MR", |
| "480": "MU", |
| "484": "MX", |
| "492": "MC", |
| "496": "MN", |
| "498": "MD", |
| "499": "ME", |
| "500": "MS", |
| "504": "MA", |
| "508": "MZ", |
| "512": "OM", |
| "516": "NA", |
| "520": "NR", |
| "524": "NP", |
| "528": "NL", |
| "531": "CW", |
| "533": "AW", |
| "534": "SX", |
| "535": "BQ", |
| "540": "NC", |
| "548": "VU", |
| "554": "NZ", |
| "558": "NI", |
| "562": "NE", |
| "566": "NG", |
| "570": "NU", |
| "574": "NF", |
| "578": "NO", |
| "580": "MP", |
| "581": "UM", |
| "583": "FM", |
| "584": "MH", |
| "585": "PW", |
| "586": "PK", |
| "591": "PA", |
| "598": "PG", |
| "600": "PY", |
| "604": "PE", |
| "608": "PH", |
| "612": "PN", |
| "616": "PL", |
| "620": "PT", |
| "624": "GW", |
| "626": "TL", |
| "630": "PR", |
| "634": "QA", |
| "638": "RE", |
| "642": "RO", |
| "643": "RU", |
| "646": "RW", |
| "652": "BL", |
| "654": "SH", |
| "659": "KN", |
| "660": "AI", |
| "662": "LC", |
| "663": "MF", |
| "666": "PM", |
| "670": "VC", |
| "674": "SM", |
| "678": "ST", |
| "682": "SA", |
| "686": "SN", |
| "688": "RS", |
| "690": "SC", |
| "694": "SL", |
| "702": "SG", |
| "703": "SK", |
| "704": "VN", |
| "705": "SI", |
| "706": "SO", |
| "710": "ZA", |
| "716": "ZW", |
| "720": "YE", |
| "724": "ES", |
| "728": "SS", |
| "729": "SD", |
| "732": "EH", |
| "736": "SD", |
| "740": "SR", |
| "744": "SJ", |
| "748": "SZ", |
| "752": "SE", |
| "756": "CH", |
| "760": "SY", |
| "762": "TJ", |
| "764": "TH", |
| "768": "TG", |
| "772": "TK", |
| "776": "TO", |
| "780": "TT", |
| "784": "AE", |
| "788": "TN", |
| "792": "TR", |
| "795": "TM", |
| "796": "TC", |
| "798": "TV", |
| "800": "UG", |
| "804": "UA", |
| "807": "MK", |
| "818": "EG", |
| "826": "GB", |
| "830": "JE", |
| "831": "GG", |
| "832": "JE", |
| "833": "IM", |
| "834": "TZ", |
| "840": "US", |
| "850": "VI", |
| "854": "BF", |
| "858": "UY", |
| "860": "UZ", |
| "862": "VE", |
| "876": "WF", |
| "882": "WS", |
| "886": "YE", |
| "887": "YE", |
| "891": "RS", |
| "894": "ZM", |
| "958": "AA", |
| "959": "QM", |
| "960": "QN", |
| "962": "QP", |
| "963": "QQ", |
| "964": "QR", |
| "965": "QS", |
| "966": "QT", |
| "967": "EU", |
| "968": "QV", |
| "969": "QW", |
| "970": "QX", |
| "971": "QY", |
| "972": "QZ", |
| "973": "XA", |
| "974": "XB", |
| "975": "XC", |
| "976": "XD", |
| "977": "XE", |
| "978": "XF", |
| "979": "XG", |
| "980": "XH", |
| "981": "XI", |
| "982": "XJ", |
| "983": "XK", |
| "984": "XL", |
| "985": "XM", |
| "986": "XN", |
| "987": "XO", |
| "988": "XP", |
| "989": "XQ", |
| "990": "XR", |
| "991": "XS", |
| "992": "XT", |
| "993": "XU", |
| "994": "XV", |
| "995": "XW", |
| "996": "XX", |
| "997": "XY", |
| "998": "XZ", |
| "999": "ZZ", |
| "BU": "MM", |
| "CS": "RS", |
| "CT": "KI", |
| "DD": "DE", |
| "DY": "BJ", |
| "FQ": "AQ", |
| "FX": "FR", |
| "HV": "BF", |
| "JT": "UM", |
| "MI": "UM", |
| "NH": "VU", |
| "NQ": "AQ", |
| "PU": "UM", |
| "PZ": "PA", |
| "QU": "EU", |
| "RH": "ZW", |
| "TP": "TL", |
| "UK": "GB", |
| "VD": "VN", |
| "WK": "UM", |
| "YD": "YE", |
| "YU": "RS", |
| "ZR": "CD", |
| }; |
| |
| |
| /** |
| * Canonicalizes the given well-formed BCP 47 language tag, including regularized case of subtags. |
| * |
| * Spec: ECMAScript Internationalization API Specification, draft, 6.2.3. |
| * Spec: RFC 5646, section 4.5. |
| */ |
| function canonicalizeLanguageTag(locale) { |
| |
| // start with lower case for easier processing, and because most subtags will need to be lower case anyway |
| locale = locale.toLowerCase(); |
| |
| // handle mappings for complete tags |
| if (__tagMappings.hasOwnProperty(locale)) { |
| return __tagMappings[locale]; |
| } |
| |
| var subtags = locale.split("-"); |
| var i = 0; |
| |
| // handle standard part: all subtags before first variant or singleton subtag |
| var language; |
| var script; |
| var region; |
| while (i < subtags.length) { |
| var subtag = subtags[i]; |
| if (i === 0) { |
| language = subtag; |
| } else if (subtag.length === 2 || subtag.length === 3) { |
| region = subtag.toUpperCase(); |
| } else if (subtag.length === 4 && !("0" <= subtag[0] && subtag[0] <= "9")) { |
| script = subtag[0].toUpperCase() + subtag.substring(1).toLowerCase(); |
| } else { |
| break; |
| } |
| i++; |
| } |
| |
| if (__languageMappings.hasOwnProperty(language)) { |
| language = __languageMappings[language]; |
| } else { |
| // Language subtags with complex mappings, CLDR 35. |
| switch (language) { |
| case "cnr": |
| language = "sr"; |
| if (region === undefined) { |
| region = "ME"; |
| } |
| break; |
| case "drw": |
| case "prs": |
| case "tnf": |
| language = "fa"; |
| if (region === undefined) { |
| region = "AF"; |
| } |
| break; |
| case "hbs": |
| case "sh": |
| language = "sr"; |
| if (script === undefined) { |
| script = "Latn"; |
| } |
| break; |
| case "swc": |
| language = "sw"; |
| if (region === undefined) { |
| region = "CD"; |
| } |
| break; |
| } |
| } |
| |
| if (region !== undefined) { |
| if (__regionMappings.hasOwnProperty(region)) { |
| region = __regionMappings[region]; |
| } else { |
| // Region subtags with complex mappings, CLDR 35. |
| switch (region) { |
| case "172": |
| if (language === "ab" || language === "ka" || language === "os" || |
| (language === "und" && script === "Geor") || language === "xmf") { |
| region = "GE"; |
| } |
| else if (language === "az" || language === "tkr" || language === "tly" || language === "ttt") { |
| region = "AZ"; |
| } |
| else if (language === "be") { |
| region = "BY"; |
| } |
| else if (language === "crh" || language === "got" || language === "ji" || language === "rue" || |
| language === "uk" || (language === "und" && script === "Goth")) { |
| region = "UA"; |
| } |
| else if (language === "gag") { |
| region = "MD"; |
| } |
| else if (language === "hy" || (language === "und" && script === "Armn")) { |
| region = "AM"; |
| } |
| else if (language === "kaa" || language === "sog" || (language === "und" && script === "Sogd") || |
| (language === "und" && script === "Sogo") || language === "uz") { |
| region = "UZ"; |
| } |
| else if (language === "kk" || (language === "ug" && script === "Cyrl")) { |
| region = "KZ"; |
| } |
| else if (language === "ky") { |
| region = "KG"; |
| } |
| else if (language === "tg") { |
| region = "TJ"; |
| } |
| else if (language === "tk") { |
| region = "TM"; |
| } |
| else { |
| region = "RU"; |
| } |
| break; |
| case "200": |
| if (language === "sk") { |
| region = "SK"; |
| } |
| else { |
| region = "CZ"; |
| } |
| break; |
| case "530": |
| case "532": |
| case "AN": |
| if (language === "vic") { |
| region = "SX"; |
| } |
| else { |
| region = "CW"; |
| } |
| break; |
| case "536": |
| case "NT": |
| if (language === "akk" || language === "ckb" || (language === "ku" && script === "Arab") || |
| language === "mis" || language === "syr" || (language === "und" && script === "Xsux") || |
| (language === "und" && script === "Hatr") || (language === "und" && script === "Syrc")) { |
| region = "IQ"; |
| } |
| else { |
| region = "SA"; |
| } |
| break; |
| case "582": |
| case "PC": |
| if (language === "mh") { |
| region = "MH"; |
| } |
| else if (language === "pau") { |
| region = "PW"; |
| } |
| else { |
| region = "FM"; |
| } |
| break; |
| case "810": |
| case "SU": |
| if (language === "ab" || language === "ka" || language === "os" || language === "xmf" || |
| (language === "und" && script === "Geor")) { |
| region = "GE"; |
| } |
| else if (language === "az" || language === "tkr" || language === "tly" || language === "ttt") { |
| region = "AZ"; |
| } |
| else if (language === "be") { |
| region = "BY"; |
| } |
| else if (language === "crh" || language === "got" || language === "ji" || language === "rue" || |
| language === "uk" || (language === "und" && script === "Goth")) { |
| region = "UA"; |
| } |
| else if (language === "et" || language === "vro") { |
| region = "EE"; |
| } |
| else if (language === "gag") { |
| region = "MD"; |
| } |
| else if (language === "hy" || (language === "und" && script === "Armn")) { |
| region = "AM"; |
| } |
| else if (language === "kaa" || language === "sog" || (language === "und" && script === "Sogd") || |
| (language === "und" && script === "Sogo") || language === "uz") { |
| region = "UZ"; |
| } |
| else if (language === "kk" || (language === "ug" && script === "Cyrl")) { |
| region = "KZ"; |
| } |
| else if (language === "ky") { |
| region = "KG"; |
| } |
| else if (language === "lt" || language === "sgs") { |
| region = "LT"; |
| } |
| else if (language === "ltg" || language === "lv") { |
| region = "LV"; |
| } |
| else if (language === "tg") { |
| region = "TJ"; |
| } |
| else if (language === "tk") { |
| region = "TM"; |
| } |
| else { |
| region = "RU"; |
| } |
| break; |
| case "890": |
| if (language === "bs") { |
| region = "BA"; |
| } |
| else if (language === "hr") { |
| region = "HR"; |
| } |
| else if (language === "mk") { |
| region = "MK"; |
| } |
| else if (language === "sl") { |
| region = "SI"; |
| } |
| else { |
| region = "RS"; |
| } |
| break; |
| } |
| } |
| } |
| |
| // handle variants |
| var variants = []; |
| while (i < subtags.length && subtags[i].length > 1) { |
| variants.push(subtags[i]); |
| i += 1; |
| } |
| variants.sort(); |
| |
| // handle extensions |
| var extensions = []; |
| while (i < subtags.length && subtags[i] !== "x") { |
| var extensionStart = i; |
| i++; |
| while (i < subtags.length && subtags[i].length > 1) { |
| i++; |
| } |
| var extension = subtags.slice(extensionStart, i).join("-"); |
| extensions.push(extension); |
| } |
| extensions.sort(); |
| |
| // handle private use |
| var privateUse; |
| if (i < subtags.length) { |
| privateUse = subtags.slice(i).join("-"); |
| } |
| |
| // put everything back together |
| var canonical = language; |
| if (script !== undefined) { |
| canonical += "-" + script; |
| } |
| if (region !== undefined) { |
| canonical += "-" + region; |
| } |
| if (variants.length > 0) { |
| canonical += "-" + variants.join("-"); |
| } |
| if (extensions.length > 0) { |
| canonical += "-" + extensions.join("-"); |
| } |
| if (privateUse !== undefined) { |
| if (canonical.length > 0) { |
| canonical += "-" + privateUse; |
| } else { |
| canonical = privateUse; |
| } |
| } |
| |
| return canonical; |
| } |
| |
| return typeof locale === "string" && isStructurallyValidLanguageTag(locale) && |
| canonicalizeLanguageTag(locale) === locale; |
| } |
| |
| |
| /** |
| * Returns an array of error cases handled by CanonicalizeLocaleList(). |
| */ |
| function getInvalidLocaleArguments() { |
| function CustomError() {} |
| |
| var topLevelErrors = [ |
| // fails ToObject |
| [null, TypeError], |
| |
| // fails Get |
| [{ get length() { throw new CustomError(); } }, CustomError], |
| |
| // fail ToLength |
| [{ length: Symbol.toPrimitive }, TypeError], |
| [{ length: { get [Symbol.toPrimitive]() { throw new CustomError(); } } }, CustomError], |
| [{ length: { [Symbol.toPrimitive]() { throw new CustomError(); } } }, CustomError], |
| [{ length: { get valueOf() { throw new CustomError(); } } }, CustomError], |
| [{ length: { valueOf() { throw new CustomError(); } } }, CustomError], |
| [{ length: { get toString() { throw new CustomError(); } } }, CustomError], |
| [{ length: { toString() { throw new CustomError(); } } }, CustomError], |
| |
| // fail type check |
| [[undefined], TypeError], |
| [[null], TypeError], |
| [[true], TypeError], |
| [[Symbol.toPrimitive], TypeError], |
| [[1], TypeError], |
| [[0.1], TypeError], |
| [[NaN], TypeError], |
| ]; |
| |
| var invalidLanguageTags = [ |
| "", // empty tag |
| "i", // singleton alone |
| "x", // private use without subtag |
| "u", // extension singleton in first place |
| "419", // region code in first place |
| "u-nu-latn-cu-bob", // extension sequence without language |
| "hans-cmn-cn", // "hans" could theoretically be a 4-letter language code, |
| // but those can't be followed by extlang codes. |
| "abcdefghi", // overlong language |
| "cmn-hans-cn-u-u", // duplicate singleton |
| "cmn-hans-cn-t-u-ca-u", // duplicate singleton |
| "de-gregory-gregory", // duplicate variant |
| "*", // language range |
| "de-*", // language range |
| "中文", // non-ASCII letters |
| "en-ß", // non-ASCII letters |
| "ıd" // non-ASCII letters |
| ]; |
| |
| return topLevelErrors.concat( |
| invalidLanguageTags.map(tag => [tag, RangeError]), |
| invalidLanguageTags.map(tag => [[tag], RangeError]), |
| invalidLanguageTags.map(tag => [["en", tag], RangeError]), |
| ) |
| } |
| |
| /** |
| * Tests whether the named options property is correctly handled by the given constructor. |
| * @param {object} Constructor the constructor to test. |
| * @param {string} property the name of the options property to test. |
| * @param {string} type the type that values of the property are expected to have |
| * @param {Array} [values] an array of allowed values for the property. Not needed for boolean. |
| * @param {any} fallback the fallback value that the property assumes if not provided. |
| * @param {object} testOptions additional options: |
| * @param {boolean} isOptional whether support for this property is optional for implementations. |
| * @param {boolean} noReturn whether the resulting value of the property is not returned. |
| * @param {boolean} isILD whether the resulting value of the property is implementation and locale dependent. |
| * @param {object} extra additional option to pass along, properties are value -> {option: value}. |
| */ |
| function testOption(Constructor, property, type, values, fallback, testOptions) { |
| var isOptional = testOptions !== undefined && testOptions.isOptional === true; |
| var noReturn = testOptions !== undefined && testOptions.noReturn === true; |
| var isILD = testOptions !== undefined && testOptions.isILD === true; |
| |
| function addExtraOptions(options, value, testOptions) { |
| if (testOptions !== undefined && testOptions.extra !== undefined) { |
| var extra; |
| if (value !== undefined && testOptions.extra[value] !== undefined) { |
| extra = testOptions.extra[value]; |
| } else if (testOptions.extra.any !== undefined) { |
| extra = testOptions.extra.any; |
| } |
| if (extra !== undefined) { |
| Object.getOwnPropertyNames(extra).forEach(function (prop) { |
| options[prop] = extra[prop]; |
| }); |
| } |
| } |
| } |
| |
| var testValues, options, obj, expected, actual, error; |
| |
| // test that the specified values are accepted. Also add values that convert to specified values. |
| if (type === "boolean") { |
| if (values === undefined) { |
| values = [true, false]; |
| } |
| testValues = values.slice(0); |
| testValues.push(888); |
| testValues.push(0); |
| } else if (type === "string") { |
| testValues = values.slice(0); |
| testValues.push({toString: function () { return values[0]; }}); |
| } |
| testValues.forEach(function (value) { |
| options = {}; |
| options[property] = value; |
| addExtraOptions(options, value, testOptions); |
| obj = new Constructor(undefined, options); |
| if (noReturn) { |
| if (obj.resolvedOptions().hasOwnProperty(property)) { |
| $ERROR("Option property " + property + " is returned, but shouldn't be."); |
| } |
| } else { |
| actual = obj.resolvedOptions()[property]; |
| if (isILD) { |
| if (actual !== undefined && values.indexOf(actual) === -1) { |
| $ERROR("Invalid value " + actual + " returned for property " + property + "."); |
| } |
| } else { |
| if (type === "boolean") { |
| expected = Boolean(value); |
| } else if (type === "string") { |
| expected = String(value); |
| } |
| if (actual !== expected && !(isOptional && actual === undefined)) { |
| $ERROR("Option value " + value + " for property " + property + |
| " was not accepted; got " + actual + " instead."); |
| } |
| } |
| } |
| }); |
| |
| // test that invalid values are rejected |
| if (type === "string") { |
| var invalidValues = ["invalidValue", -1, null]; |
| // assume that we won't have values in caseless scripts |
| if (values[0].toUpperCase() !== values[0]) { |
| invalidValues.push(values[0].toUpperCase()); |
| } else { |
| invalidValues.push(values[0].toLowerCase()); |
| } |
| invalidValues.forEach(function (value) { |
| options = {}; |
| options[property] = value; |
| addExtraOptions(options, value, testOptions); |
| error = undefined; |
| try { |
| obj = new Constructor(undefined, options); |
| } catch (e) { |
| error = e; |
| } |
| if (error === undefined) { |
| $ERROR("Invalid option value " + value + " for property " + property + " was not rejected."); |
| } else if (error.name !== "RangeError") { |
| $ERROR("Invalid option value " + value + " for property " + property + " was rejected with wrong error " + error.name + "."); |
| } |
| }); |
| } |
| |
| // test that fallback value or another valid value is used if no options value is provided |
| if (!noReturn) { |
| options = {}; |
| addExtraOptions(options, undefined, testOptions); |
| obj = new Constructor(undefined, options); |
| actual = obj.resolvedOptions()[property]; |
| if (!(isOptional && actual === undefined)) { |
| if (fallback !== undefined) { |
| if (actual !== fallback) { |
| $ERROR("Option fallback value " + fallback + " for property " + property + |
| " was not used; got " + actual + " instead."); |
| } |
| } else { |
| if (values.indexOf(actual) === -1 && !(isILD && actual === undefined)) { |
| $ERROR("Invalid value " + actual + " returned for property " + property + "."); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Properties of the RegExp constructor that may be affected by use of regular |
| * expressions, and the default values of these properties. Properties are from |
| * https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Deprecated_and_obsolete_features#RegExp_Properties |
| */ |
| var regExpProperties = ["$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", |
| "$_", "$*", "$&", "$+", "$`", "$'", |
| "input", "lastMatch", "lastParen", "leftContext", "rightContext" |
| ]; |
| |
| var regExpPropertiesDefaultValues = (function () { |
| var values = Object.create(null); |
| regExpProperties.forEach(function (property) { |
| values[property] = RegExp[property]; |
| }); |
| return values; |
| }()); |
| |
| |
| /** |
| * Tests that executing the provided function (which may use regular expressions |
| * in its implementation) does not create or modify unwanted properties on the |
| * RegExp constructor. |
| */ |
| function testForUnwantedRegExpChanges(testFunc) { |
| regExpProperties.forEach(function (property) { |
| RegExp[property] = regExpPropertiesDefaultValues[property]; |
| }); |
| testFunc(); |
| regExpProperties.forEach(function (property) { |
| if (RegExp[property] !== regExpPropertiesDefaultValues[property]) { |
| $ERROR("RegExp has unexpected property " + property + " with value " + |
| RegExp[property] + "."); |
| } |
| }); |
| } |
| |
| |
| /** |
| * Tests whether name is a valid BCP 47 numbering system name |
| * and not excluded from use in the ECMAScript Internationalization API. |
| * @param {string} name the name to be tested. |
| * @return {boolean} whether name is a valid BCP 47 numbering system name and |
| * allowed for use in the ECMAScript Internationalization API. |
| */ |
| |
| function isValidNumberingSystem(name) { |
| |
| // source: CLDR file common/bcp47/number.xml; version CLDR 32. |
| var numberingSystems = [ |
| "adlm", |
| "ahom", |
| "arab", |
| "arabext", |
| "armn", |
| "armnlow", |
| "bali", |
| "beng", |
| "bhks", |
| "brah", |
| "cakm", |
| "cham", |
| "cyrl", |
| "deva", |
| "ethi", |
| "finance", |
| "fullwide", |
| "geor", |
| "gonm", |
| "grek", |
| "greklow", |
| "gujr", |
| "guru", |
| "hanidays", |
| "hanidec", |
| "hans", |
| "hansfin", |
| "hant", |
| "hantfin", |
| "hebr", |
| "hmng", |
| "java", |
| "jpan", |
| "jpanfin", |
| "kali", |
| "khmr", |
| "knda", |
| "lana", |
| "lanatham", |
| "laoo", |
| "latn", |
| "lepc", |
| "limb", |
| "mathbold", |
| "mathdbl", |
| "mathmono", |
| "mathsanb", |
| "mathsans", |
| "mlym", |
| "modi", |
| "mong", |
| "mroo", |
| "mtei", |
| "mymr", |
| "mymrshan", |
| "mymrtlng", |
| "native", |
| "newa", |
| "nkoo", |
| "olck", |
| "orya", |
| "osma", |
| "roman", |
| "romanlow", |
| "saur", |
| "shrd", |
| "sind", |
| "sinh", |
| "sora", |
| "sund", |
| "takr", |
| "talu", |
| "taml", |
| "tamldec", |
| "telu", |
| "thai", |
| "tirh", |
| "tibt", |
| "traditio", |
| "vaii", |
| "wara", |
| ]; |
| |
| var excluded = [ |
| "finance", |
| "native", |
| "traditio" |
| ]; |
| |
| |
| return numberingSystems.indexOf(name) !== -1 && excluded.indexOf(name) === -1; |
| } |
| |
| |
| /** |
| * Provides the digits of numbering systems with simple digit mappings, |
| * as specified in 11.3.2. |
| */ |
| |
| var numberingSystemDigits = { |
| arab: "٠١٢٣٤٥٦٧٨٩", |
| arabext: "۰۱۲۳۴۵۶۷۸۹", |
| bali: "\u1B50\u1B51\u1B52\u1B53\u1B54\u1B55\u1B56\u1B57\u1B58\u1B59", |
| beng: "০১২৩৪৫৬৭৮৯", |
| deva: "०१२३४५६७८९", |
| fullwide: "０１２３４５６７８９", |
| gujr: "૦૧૨૩૪૫૬૭૮૯", |
| guru: "੦੧੨੩੪੫੬੭੮੯", |
| hanidec: "〇一二三四五六七八九", |
| khmr: "០១២៣៤៥៦៧៨៩", |
| knda: "೦೧೨೩೪೫೬೭೮೯", |
| laoo: "໐໑໒໓໔໕໖໗໘໙", |
| latn: "0123456789", |
| limb: "\u1946\u1947\u1948\u1949\u194A\u194B\u194C\u194D\u194E\u194F", |
| mlym: "൦൧൨൩൪൫൬൭൮൯", |
| mong: "᠐᠑᠒᠓᠔᠕᠖᠗᠘᠙", |
| mymr: "၀၁၂၃၄၅၆၇၈၉", |
| orya: "୦୧୨୩୪୫୬୭୮୯", |
| tamldec: "௦௧௨௩௪௫௬௭௮௯", |
| telu: "౦౧౨౩౪౫౬౭౮౯", |
| thai: "๐๑๒๓๔๕๖๗๘๙", |
| tibt: "༠༡༢༣༤༥༦༧༨༩" |
| }; |
| |
| |
| /** |
| * Tests that number formatting is handled correctly. The function checks that the |
| * digit sequences in formatted output are as specified, converted to the |
| * selected numbering system, and embedded in consistent localized patterns. |
| * @param {Array} locales the locales to be tested. |
| * @param {Array} numberingSystems the numbering systems to be tested. |
| * @param {Object} options the options to pass to Intl.NumberFormat. Options |
| * must include {useGrouping: false}, and must cause 1.1 to be formatted |
| * pre- and post-decimal digits. |
| * @param {Object} testData maps input data (in ES5 9.3.1 format) to expected output strings |
| * in unlocalized format with Western digits. |
| */ |
| |
| function testNumberFormat(locales, numberingSystems, options, testData) { |
| locales.forEach(function (locale) { |
| numberingSystems.forEach(function (numbering) { |
| var digits = numberingSystemDigits[numbering]; |
| var format = new Intl.NumberFormat([locale + "-u-nu-" + numbering], options); |
| |
| function getPatternParts(positive) { |
| var n = positive ? 1.1 : -1.1; |
| var formatted = format.format(n); |
| var oneoneRE = "([^" + digits + "]*)[" + digits + "]+([^" + digits + "]+)[" + digits + "]+([^" + digits + "]*)"; |
| var match = formatted.match(new RegExp(oneoneRE)); |
| if (match === null) { |
| $ERROR("Unexpected formatted " + n + " for " + |
| format.resolvedOptions().locale + " and options " + |
| JSON.stringify(options) + ": " + formatted); |
| } |
| return match; |
| } |
| |
| function toNumbering(raw) { |
| return raw.replace(/[0-9]/g, function (digit) { |
| return digits[digit.charCodeAt(0) - "0".charCodeAt(0)]; |
| }); |
| } |
| |
| function buildExpected(raw, patternParts) { |
| var period = raw.indexOf("."); |
| if (period === -1) { |
| return patternParts[1] + toNumbering(raw) + patternParts[3]; |
| } else { |
| return patternParts[1] + |
| toNumbering(raw.substring(0, period)) + |
| patternParts[2] + |
| toNumbering(raw.substring(period + 1)) + |
| patternParts[3]; |
| } |
| } |
| |
| if (format.resolvedOptions().numberingSystem === numbering) { |
| // figure out prefixes, infixes, suffixes for positive and negative values |
| var posPatternParts = getPatternParts(true); |
| var negPatternParts = getPatternParts(false); |
| |
| Object.getOwnPropertyNames(testData).forEach(function (input) { |
| var rawExpected = testData[input]; |
| var patternParts; |
| if (rawExpected[0] === "-") { |
| patternParts = negPatternParts; |
| rawExpected = rawExpected.substring(1); |
| } else { |
| patternParts = posPatternParts; |
| } |
| var expected = buildExpected(rawExpected, patternParts); |
| var actual = format.format(input); |
| if (actual !== expected) { |
| $ERROR("Formatted value for " + input + ", " + |
| format.resolvedOptions().locale + " and options " + |
| JSON.stringify(options) + " is " + actual + "; expected " + expected + "."); |
| } |
| }); |
| } |
| }); |
| }); |
| } |
| |
| |
| /** |
| * Return the components of date-time formats. |
| * @return {Array} an array with all date-time components. |
| */ |
| |
| function getDateTimeComponents() { |
| return ["weekday", "era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"]; |
| } |
| |
| |
| /** |
| * Return the valid values for the given date-time component, as specified |
| * by the table in section 12.1.1. |
| * @param {string} component a date-time component. |
| * @return {Array} an array with the valid values for the component. |
| */ |
| |
| function getDateTimeComponentValues(component) { |
| |
| var components = { |
| weekday: ["narrow", "short", "long"], |
| era: ["narrow", "short", "long"], |
| year: ["2-digit", "numeric"], |
| month: ["2-digit", "numeric", "narrow", "short", "long"], |
| day: ["2-digit", "numeric"], |
| hour: ["2-digit", "numeric"], |
| minute: ["2-digit", "numeric"], |
| second: ["2-digit", "numeric"], |
| timeZoneName: ["short", "long"] |
| }; |
| |
| var result = components[component]; |
| if (result === undefined) { |
| $ERROR("Internal error: No values defined for date-time component " + component + "."); |
| } |
| return result; |
| } |
| |
| |
| /** |
| * @description Tests whether timeZone is a String value representing a |
| * structurally valid and canonicalized time zone name, as defined in |
| * sections 6.4.1 and 6.4.2 of the ECMAScript Internationalization API |
| * Specification. |
| * @param {String} timeZone the string to be tested. |
| * @result {Boolean} whether the test succeeded. |
| */ |
| |
| function isCanonicalizedStructurallyValidTimeZoneName(timeZone) { |
| /** |
| * Regular expression defining IANA Time Zone names. |
| * |
| * Spec: IANA Time Zone Database, Theory file |
| */ |
| var fileNameComponent = "(?:[A-Za-z_]|\\.(?!\\.?(?:/|$)))[A-Za-z.\\-_]{0,13}"; |
| var fileName = fileNameComponent + "(?:/" + fileNameComponent + ")*"; |
| var etcName = "(?:Etc/)?GMT[+-]\\d{1,2}"; |
| var systemVName = "SystemV/[A-Z]{3}\\d{1,2}(?:[A-Z]{3})?"; |
| var legacyName = etcName + "|" + systemVName + "|CST6CDT|EST5EDT|MST7MDT|PST8PDT|NZ"; |
| var zoneNamePattern = new RegExp("^(?:" + fileName + "|" + legacyName + ")$"); |
| |
| if (typeof timeZone !== "string") { |
| return false; |
| } |
| // 6.4.2 CanonicalizeTimeZoneName (timeZone), step 3 |
| if (timeZone === "UTC") { |
| return true; |
| } |
| // 6.4.2 CanonicalizeTimeZoneName (timeZone), step 3 |
| if (timeZone === "Etc/UTC" || timeZone === "Etc/GMT") { |
| return false; |
| } |
| return zoneNamePattern.test(timeZone); |
| } |
