deploy: v0.12 fix 存档key名

node_modules/@formatjs/intl-localematcher/lib/abstract/BestAvailableLocale.d.ts

@@ -0,0 +1,6 @@
+/**
+ * https://tc39.es/ecma402/#sec-bestavailablelocale
+ * @param availableLocales
+ * @param locale
+ */
+export declare function BestAvailableLocale(availableLocales: readonly string[], locale: string): string | undefined;

node_modules/@formatjs/intl-localematcher/lib/abstract/BestAvailableLocale.js

@@ -0,0 +1,21 @@
+/**
+ * https://tc39.es/ecma402/#sec-bestavailablelocale
+ * @param availableLocales
+ * @param locale
+ */
+export function BestAvailableLocale(availableLocales, locale) {
+    var candidate = locale;
+    while (true) {
+        if (availableLocales.indexOf(candidate) > -1) {
+            return candidate;
+        }
+        var pos = candidate.lastIndexOf('-');
+        if (!~pos) {
+            return undefined;
+        }
+        if (pos >= 2 && candidate[pos - 2] === '-') {
+            pos -= 2;
+        }
+        candidate = candidate.slice(0, pos);
+    }
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/BestFitMatcher.d.ts

@@ -0,0 +1,8 @@
+import { LookupMatcherResult } from './types';
+/**
+ * https://tc39.es/ecma402/#sec-bestfitmatcher
+ * @param availableLocales
+ * @param requestedLocales
+ * @param getDefaultLocale
+ */
+export declare function BestFitMatcher(availableLocales: readonly string[], requestedLocales: readonly string[], getDefaultLocale: () => string): LookupMatcherResult;

node_modules/@formatjs/intl-localematcher/lib/abstract/BestFitMatcher.js

@@ -0,0 +1,31 @@
+import { UNICODE_EXTENSION_SEQUENCE_REGEX, findBestMatch } from './utils';
+/**
+ * https://tc39.es/ecma402/#sec-bestfitmatcher
+ * @param availableLocales
+ * @param requestedLocales
+ * @param getDefaultLocale
+ */
+export function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
+    var foundLocale;
+    var extension;
+    var noExtensionLocales = [];
+    var noExtensionLocaleMap = requestedLocales.reduce(function (all, l) {
+        var noExtensionLocale = l.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
+        noExtensionLocales.push(noExtensionLocale);
+        all[noExtensionLocale] = l;
+        return all;
+    }, {});
+    var result = findBestMatch(noExtensionLocales, availableLocales);
+    if (result.matchedSupportedLocale && result.matchedDesiredLocale) {
+        foundLocale = result.matchedSupportedLocale;
+        extension =
+            noExtensionLocaleMap[result.matchedDesiredLocale].slice(result.matchedDesiredLocale.length) || undefined;
+    }
+    if (!foundLocale) {
+        return { locale: getDefaultLocale() };
+    }
+    return {
+        locale: foundLocale,
+        extension: extension,
+    };
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/CanonicalizeLocaleList.d.ts

@@ -0,0 +1,5 @@
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
+ * @param locales
+ */
+export declare function CanonicalizeLocaleList(locales?: string | readonly string[]): string[];

node_modules/@formatjs/intl-localematcher/lib/abstract/CanonicalizeLocaleList.js

@@ -0,0 +1,7 @@
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
+ * @param locales
+ */
+export function CanonicalizeLocaleList(locales) {
+    return Intl.getCanonicalLocales(locales);
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/CanonicalizeUValue.d.ts

@@ -0,0 +1 @@
+export declare function CanonicalizeUValue(ukey: string, uvalue: string): string;

node_modules/@formatjs/intl-localematcher/lib/abstract/CanonicalizeUValue.js

@@ -0,0 +1,8 @@
+import { invariant } from './utils';
+export function CanonicalizeUValue(ukey, uvalue) {
+    // TODO: Implement algorithm for CanonicalizeUValue per https://tc39.es/ecma402/#sec-canonicalizeuvalue
+    var lowerValue = uvalue.toLowerCase();
+    invariant(ukey !== undefined, "ukey must be defined");
+    var canonicalized = lowerValue;
+    return canonicalized;
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/CanonicalizeUnicodeLocaleId.d.ts

@@ -0,0 +1 @@
+export declare function CanonicalizeUnicodeLocaleId(locale: string): string;

node_modules/@formatjs/intl-localematcher/lib/abstract/CanonicalizeUnicodeLocaleId.js

@@ -0,0 +1,3 @@
+export function CanonicalizeUnicodeLocaleId(locale) {
+    return Intl.getCanonicalLocales(locale)[0];
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/InsertUnicodeExtensionAndCanonicalize.d.ts

@@ -0,0 +1,2 @@
+import { Keyword } from './types';
+export declare function InsertUnicodeExtensionAndCanonicalize(locale: string, attributes: string[], keywords: Array<Keyword>): string;

node_modules/@formatjs/intl-localematcher/lib/abstract/InsertUnicodeExtensionAndCanonicalize.js

@@ -0,0 +1,32 @@
+import { CanonicalizeUnicodeLocaleId } from './CanonicalizeUnicodeLocaleId';
+import { invariant } from './utils';
+export function InsertUnicodeExtensionAndCanonicalize(locale, attributes, keywords) {
+    invariant(locale.indexOf('-u-') === -1, 'Expected locale to not have a Unicode locale extension');
+    var extension = '-u';
+    for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
+        var attr = attributes_1[_i];
+        extension += "-".concat(attr);
+    }
+    for (var _a = 0, keywords_1 = keywords; _a < keywords_1.length; _a++) {
+        var kw = keywords_1[_a];
+        var key = kw.key, value = kw.value;
+        extension += "-".concat(key);
+        if (value !== '') {
+            extension += "-".concat(value);
+        }
+    }
+    if (extension === '-u') {
+        return CanonicalizeUnicodeLocaleId(locale);
+    }
+    var privateIndex = locale.indexOf('-x-');
+    var newLocale;
+    if (privateIndex === -1) {
+        newLocale = locale + extension;
+    }
+    else {
+        var preExtension = locale.slice(0, privateIndex);
+        var postExtension = locale.slice(privateIndex);
+        newLocale = preExtension + extension + postExtension;
+    }
+    return CanonicalizeUnicodeLocaleId(newLocale);
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/LookupMatcher.d.ts

@@ -0,0 +1,8 @@
+import { LookupMatcherResult } from './types';
+/**
+ * https://tc39.es/ecma402/#sec-lookupmatcher
+ * @param availableLocales
+ * @param requestedLocales
+ * @param getDefaultLocale
+ */
+export declare function LookupMatcher(availableLocales: readonly string[], requestedLocales: readonly string[], getDefaultLocale: () => string): LookupMatcherResult;

node_modules/@formatjs/intl-localematcher/lib/abstract/LookupMatcher.js

@@ -0,0 +1,25 @@
+import { BestAvailableLocale } from './BestAvailableLocale';
+import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils';
+/**
+ * https://tc39.es/ecma402/#sec-lookupmatcher
+ * @param availableLocales
+ * @param requestedLocales
+ * @param getDefaultLocale
+ */
+export function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
+    var result = { locale: '' };
+    for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
+        var locale = requestedLocales_1[_i];
+        var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
+        var availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
+        if (availableLocale) {
+            result.locale = availableLocale;
+            if (locale !== noExtensionLocale) {
+                result.extension = locale.slice(noExtensionLocale.length, locale.length);
+            }
+            return result;
+        }
+    }
+    result.locale = getDefaultLocale();
+    return result;
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/LookupSupportedLocales.d.ts

@@ -0,0 +1,6 @@
+/**
+ * https://tc39.es/ecma402/#sec-lookupsupportedlocales
+ * @param availableLocales
+ * @param requestedLocales
+ */
+export declare function LookupSupportedLocales(availableLocales: string[], requestedLocales: string[]): string[];

node_modules/@formatjs/intl-localematcher/lib/abstract/LookupSupportedLocales.js

@@ -0,0 +1,19 @@
+import { BestAvailableLocale } from './BestAvailableLocale';
+import { UNICODE_EXTENSION_SEQUENCE_REGEX } from './utils';
+/**
+ * https://tc39.es/ecma402/#sec-lookupsupportedlocales
+ * @param availableLocales
+ * @param requestedLocales
+ */
+export function LookupSupportedLocales(availableLocales, requestedLocales) {
+    var subset = [];
+    for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
+        var locale = requestedLocales_1[_i];
+        var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');
+        var availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
+        if (availableLocale) {
+            subset.push(availableLocale);
+        }
+    }
+    return subset;
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/ResolveLocale.d.ts

@@ -0,0 +1,14 @@
+export interface ResolveLocaleResult {
+    locale: string;
+    dataLocale: string;
+    [k: string]: any;
+}
+/**
+ * https://tc39.es/ecma402/#sec-resolvelocale
+ */
+export declare function ResolveLocale<K extends string, D extends {
+    [k in K]: any;
+}>(availableLocales: Set<string> | readonly string[], requestedLocales: readonly string[], options: {
+    localeMatcher: string;
+    [k: string]: string;
+}, relevantExtensionKeys: K[], localeData: Record<string, D | undefined>, getDefaultLocale: () => string): ResolveLocaleResult;

node_modules/@formatjs/intl-localematcher/lib/abstract/ResolveLocale.js

@@ -0,0 +1,100 @@
+import { BestFitMatcher } from './BestFitMatcher';
+import { CanonicalizeUValue } from './CanonicalizeUValue';
+import { InsertUnicodeExtensionAndCanonicalize } from './InsertUnicodeExtensionAndCanonicalize';
+import { LookupMatcher } from './LookupMatcher';
+import { UnicodeExtensionComponents } from './UnicodeExtensionComponents';
+import { invariant } from './utils';
+/**
+ * https://tc39.es/ecma402/#sec-resolvelocale
+ */
+export function ResolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
+    var _a;
+    var matcher = options.localeMatcher;
+    var r;
+    if (matcher === 'lookup') {
+        r = LookupMatcher(Array.from(availableLocales), requestedLocales, getDefaultLocale);
+    }
+    else {
+        r = BestFitMatcher(Array.from(availableLocales), requestedLocales, getDefaultLocale);
+    }
+    if (r == null) {
+        r = {
+            locale: getDefaultLocale(),
+            extension: '',
+        };
+    }
+    var foundLocale = r.locale;
+    var foundLocaleData = localeData[foundLocale];
+    // TODO: We can't really guarantee that the locale data is available
+    // invariant(
+    //   foundLocaleData !== undefined,
+    //   `Missing locale data for ${foundLocale}`
+    // )
+    var result = { locale: 'en', dataLocale: foundLocale };
+    var components;
+    var keywords;
+    if (r.extension) {
+        components = UnicodeExtensionComponents(r.extension);
+        keywords = components.keywords;
+    }
+    else {
+        keywords = [];
+    }
+    var supportedKeywords = [];
+    var _loop_1 = function (key) {
+        // TODO: Shouldn't default to empty array, see TODO above
+        var keyLocaleData = (_a = foundLocaleData === null || foundLocaleData === void 0 ? void 0 : foundLocaleData[key]) !== null && _a !== void 0 ? _a : [];
+        invariant(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key, " must be an array"));
+        var value = keyLocaleData[0];
+        invariant(value === undefined || typeof value === 'string', "value must be a string or undefined");
+        var supportedKeyword = void 0;
+        var entry = keywords.find(function (k) { return k.key === key; });
+        if (entry) {
+            var requestedValue = entry.value;
+            if (requestedValue !== '') {
+                if (keyLocaleData.indexOf(requestedValue) > -1) {
+                    value = requestedValue;
+                    supportedKeyword = {
+                        key: key,
+                        value: value,
+                    };
+                }
+            }
+            else if (keyLocaleData.indexOf('true') > -1) {
+                value = 'true';
+                supportedKeyword = {
+                    key: key,
+                    value: value,
+                };
+            }
+        }
+        var optionsValue = options[key];
+        invariant(optionsValue == null || typeof optionsValue === 'string', "optionsValue must be a string or undefined");
+        if (typeof optionsValue === 'string') {
+            var ukey = key.toLowerCase();
+            optionsValue = CanonicalizeUValue(ukey, optionsValue);
+            if (optionsValue === '') {
+                optionsValue = 'true';
+            }
+        }
+        if (optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
+            value = optionsValue;
+            supportedKeyword = undefined;
+        }
+        if (supportedKeyword) {
+            supportedKeywords.push(supportedKeyword);
+        }
+        result[key] = value;
+    };
+    for (var _i = 0, relevantExtensionKeys_1 = relevantExtensionKeys; _i < relevantExtensionKeys_1.length; _i++) {
+        var key = relevantExtensionKeys_1[_i];
+        _loop_1(key);
+    }
+    var supportedAttributes = [];
+    if (supportedKeywords.length > 0) {
+        supportedAttributes = [];
+        foundLocale = InsertUnicodeExtensionAndCanonicalize(foundLocale, supportedAttributes, supportedKeywords);
+    }
+    result.locale = foundLocale;
+    return result;
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/UnicodeExtensionComponents.d.ts

@@ -0,0 +1,5 @@
+import { Keyword } from './types';
+export declare function UnicodeExtensionComponents(extension: string): {
+    attributes: string[];
+    keywords: Array<Keyword>;
+};

node_modules/@formatjs/intl-localematcher/lib/abstract/UnicodeExtensionComponents.js

@@ -0,0 +1,42 @@
+import { invariant } from './utils';
+export function UnicodeExtensionComponents(extension) {
+    invariant(extension === extension.toLowerCase(), 'Expected extension to be lowercase');
+    invariant(extension.slice(0, 3) === '-u-', 'Expected extension to be a Unicode locale extension');
+    var attributes = [];
+    var keywords = [];
+    var keyword;
+    var size = extension.length;
+    var k = 3;
+    while (k < size) {
+        var e = extension.indexOf('-', k);
+        var len = void 0;
+        if (e === -1) {
+            len = size - k;
+        }
+        else {
+            len = e - k;
+        }
+        var subtag = extension.slice(k, k + len);
+        invariant(len >= 2, 'Expected a subtag to have at least 2 characters');
+        if (keyword === undefined && len != 2) {
+            if (attributes.indexOf(subtag) === -1) {
+                attributes.push(subtag);
+            }
+        }
+        else if (len === 2) {
+            keyword = { key: subtag, value: '' };
+            if (keywords.find(function (k) { return k.key === (keyword === null || keyword === void 0 ? void 0 : keyword.key); }) === undefined) {
+                keywords.push(keyword);
+            }
+        }
+        else if ((keyword === null || keyword === void 0 ? void 0 : keyword.value) === '') {
+            keyword.value = subtag;
+        }
+        else {
+            invariant(keyword !== undefined, 'Expected keyword to be defined');
+            keyword.value += '-' + subtag;
+        }
+        k += len + 1;
+    }
+    return { attributes: attributes, keywords: keywords };
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/UnicodeExtensionValue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * https://tc39.es/ecma402/#sec-unicodeextensionvalue
+ * @param extension
+ * @param key
+ */
+export declare function UnicodeExtensionValue(extension: string, key: string): string | undefined;

node_modules/@formatjs/intl-localematcher/lib/abstract/UnicodeExtensionValue.js

@@ -0,0 +1,46 @@
+import { invariant } from './utils';
+/**
+ * https://tc39.es/ecma402/#sec-unicodeextensionvalue
+ * @param extension
+ * @param key
+ */
+export function UnicodeExtensionValue(extension, key) {
+    invariant(key.length === 2, 'key must have 2 elements');
+    var size = extension.length;
+    var searchValue = "-".concat(key, "-");
+    var pos = extension.indexOf(searchValue);
+    if (pos !== -1) {
+        var start = pos + 4;
+        var end = start;
+        var k = start;
+        var done = false;
+        while (!done) {
+            var e = extension.indexOf('-', k);
+            var len = void 0;
+            if (e === -1) {
+                len = size - k;
+            }
+            else {
+                len = e - k;
+            }
+            if (len === 2) {
+                done = true;
+            }
+            else if (e === -1) {
+                end = size;
+                done = true;
+            }
+            else {
+                end = e;
+                k = e + 1;
+            }
+        }
+        return extension.slice(start, end);
+    }
+    searchValue = "-".concat(key);
+    pos = extension.indexOf(searchValue);
+    if (pos !== -1 && pos + 3 === size) {
+        return '';
+    }
+    return undefined;
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/regions.generated.d.ts

@@ -0,0 +1 @@
+export declare const regions: Record<string, string[]>;

node_modules/@formatjs/intl-localematcher/lib/abstract/types.d.ts

@@ -0,0 +1,9 @@
+export interface LookupMatcherResult {
+    locale: string;
+    extension?: string;
+    nu?: string;
+}
+export interface Keyword {
+    key: string;
+    value: string;
+}

node_modules/@formatjs/intl-localematcher/lib/abstract/types.js

@@ -0,0 +1 @@
+export {};

node_modules/@formatjs/intl-localematcher/lib/abstract/utils.d.ts

@@ -0,0 +1,10 @@
+export declare const UNICODE_EXTENSION_SEQUENCE_REGEX: RegExp;
+export declare function invariant(condition: boolean, message: string, Err?: any): asserts condition;
+export declare function findMatchingDistance(desired: string, supported: string): number;
+interface LocaleMatchingResult {
+    distances: Record<string, Record<string, number>>;
+    matchedSupportedLocale?: string;
+    matchedDesiredLocale?: string;
+}
+export declare function findBestMatch(requestedLocales: readonly string[], supportedLocales: readonly string[], threshold?: number): LocaleMatchingResult;
+export {};

node_modules/@formatjs/intl-localematcher/lib/abstract/utils.js

@@ -0,0 +1,165 @@
+import { __spreadArray } from "tslib";
+import { data as jsonData } from './languageMatching';
+import { regions } from './regions.generated';
+export var UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;
+export function invariant(condition, message, Err) {
+    if (Err === void 0) { Err = Error; }
+    if (!condition) {
+        throw new Err(message);
+    }
+}
+// This is effectively 2 languages in 2 different regions in the same cluster
+var DEFAULT_MATCHING_THRESHOLD = 838;
+var PROCESSED_DATA;
+function processData() {
+    var _a, _b;
+    if (!PROCESSED_DATA) {
+        var paradigmLocales = (_b = (_a = jsonData.supplemental.languageMatching['written-new'][0]) === null || _a === void 0 ? void 0 : _a.paradigmLocales) === null || _b === void 0 ? void 0 : _b._locales.split(' ');
+        var matchVariables = jsonData.supplemental.languageMatching['written-new'].slice(1, 5);
+        var data = jsonData.supplemental.languageMatching['written-new'].slice(5);
+        var matches = data.map(function (d) {
+            var key = Object.keys(d)[0];
+            var value = d[key];
+            return {
+                supported: key,
+                desired: value._desired,
+                distance: +value._distance,
+                oneway: value.oneway === 'true' ? true : false,
+            };
+        }, {});
+        PROCESSED_DATA = {
+            matches: matches,
+            matchVariables: matchVariables.reduce(function (all, d) {
+                var key = Object.keys(d)[0];
+                var value = d[key];
+                all[key.slice(1)] = value._value.split('+');
+                return all;
+            }, {}),
+            paradigmLocales: __spreadArray(__spreadArray([], paradigmLocales, true), paradigmLocales.map(function (l) {
+                return new Intl.Locale(l.replace(/_/g, '-')).maximize().toString();
+            }), true),
+        };
+    }
+    return PROCESSED_DATA;
+}
+function isMatched(locale, languageMatchInfoLocale, matchVariables) {
+    var _a = languageMatchInfoLocale.split('-'), language = _a[0], script = _a[1], region = _a[2];
+    var matches = true;
+    if (region && region[0] === '$') {
+        var shouldInclude = region[1] !== '!';
+        var matchRegions = shouldInclude
+            ? matchVariables[region.slice(1)]
+            : matchVariables[region.slice(2)];
+        var expandedMatchedRegions = matchRegions
+            .map(function (r) { return regions[r] || [r]; })
+            .reduce(function (all, list) { return __spreadArray(__spreadArray([], all, true), list, true); }, []);
+        matches && (matches = !(expandedMatchedRegions.indexOf(locale.region || '') > 1 !=
+            shouldInclude));
+    }
+    else {
+        matches && (matches = locale.region
+            ? region === '*' || region === locale.region
+            : true);
+    }
+    matches && (matches = locale.script ? script === '*' || script === locale.script : true);
+    matches && (matches = locale.language
+        ? language === '*' || language === locale.language
+        : true);
+    return matches;
+}
+function serializeLSR(lsr) {
+    return [lsr.language, lsr.script, lsr.region].filter(Boolean).join('-');
+}
+function findMatchingDistanceForLSR(desired, supported, data) {
+    for (var _i = 0, _a = data.matches; _i < _a.length; _i++) {
+        var d = _a[_i];
+        var matches = isMatched(desired, d.desired, data.matchVariables) &&
+            isMatched(supported, d.supported, data.matchVariables);
+        if (!d.oneway && !matches) {
+            matches =
+                isMatched(desired, d.supported, data.matchVariables) &&
+                    isMatched(supported, d.desired, data.matchVariables);
+        }
+        if (matches) {
+            var distance = d.distance * 10;
+            if (data.paradigmLocales.indexOf(serializeLSR(desired)) > -1 !=
+                data.paradigmLocales.indexOf(serializeLSR(supported)) > -1) {
+                return distance - 1;
+            }
+            return distance;
+        }
+    }
+    throw new Error('No matching distance found');
+}
+export function findMatchingDistance(desired, supported) {
+    var desiredLocale = new Intl.Locale(desired).maximize();
+    var supportedLocale = new Intl.Locale(supported).maximize();
+    var desiredLSR = {
+        language: desiredLocale.language,
+        script: desiredLocale.script || '',
+        region: desiredLocale.region || '',
+    };
+    var supportedLSR = {
+        language: supportedLocale.language,
+        script: supportedLocale.script || '',
+        region: supportedLocale.region || '',
+    };
+    var matchingDistance = 0;
+    var data = processData();
+    if (desiredLSR.language !== supportedLSR.language) {
+        matchingDistance += findMatchingDistanceForLSR({
+            language: desiredLocale.language,
+            script: '',
+            region: '',
+        }, {
+            language: supportedLocale.language,
+            script: '',
+            region: '',
+        }, data);
+    }
+    if (desiredLSR.script !== supportedLSR.script) {
+        matchingDistance += findMatchingDistanceForLSR({
+            language: desiredLocale.language,
+            script: desiredLSR.script,
+            region: '',
+        }, {
+            language: supportedLocale.language,
+            script: desiredLSR.script,
+            region: '',
+        }, data);
+    }
+    if (desiredLSR.region !== supportedLSR.region) {
+        matchingDistance += findMatchingDistanceForLSR(desiredLSR, supportedLSR, data);
+    }
+    return matchingDistance;
+}
+export function findBestMatch(requestedLocales, supportedLocales, threshold) {
+    if (threshold === void 0) { threshold = DEFAULT_MATCHING_THRESHOLD; }
+    var lowestDistance = Infinity;
+    var result = {
+        matchedDesiredLocale: '',
+        distances: {},
+    };
+    requestedLocales.forEach(function (desired, i) {
+        if (!result.distances[desired]) {
+            result.distances[desired] = {};
+        }
+        supportedLocales.forEach(function (supported) {
+            // Add some weight to the distance based on the order of the supported locales
+            // Add penalty for the order of the requested locales, which currently is 0 since ECMA-402
+            // doesn't really have room for weighted locales like `en; q=0.1`
+            var distance = findMatchingDistance(desired, supported) + 0 + i * 40;
+            result.distances[desired][supported] = distance;
+            if (distance < lowestDistance) {
+                lowestDistance = distance;
+                result.matchedDesiredLocale = desired;
+                result.matchedSupportedLocale = supported;
+            }
+        });
+    });
+    if (lowestDistance >= threshold) {
+        result.matchedDesiredLocale = undefined;
+        result.matchedSupportedLocale = undefined;
+    }
+    return result;
+}