@fgv/ts-bcp47 5.1.0-2 → 5.1.0-4

package/dist/packlets/bcp47/match/chooser.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { LanguageTag } from '../languageTag';
+import { LanguageSimilarityMatcher } from './similarity';
+/**
+ * Default values for a{@link Bcp47.LanguageFilterOptions}.
+ * @public
+ */
+export const defaultLanguageChooserOptions = Object.freeze({
+    use: 'availableLanguage',
+    filter: 'primaryLanguage'
+});
+/**
+ * Helper to compare a list of 'desired' languages to a list of 'available' language
+ * and return the intersection in order of preference, taking tag semantics into account.
+ * @public
+ */
+export class LanguageChooser {
+    constructor(iana) {
+        this._matcher = new LanguageSimilarityMatcher(iana);
+    }
+    chooseLanguageTagsWithDetails(desiredLanguages, availableLanguages, options) {
+        var _a;
+        const matched = new Map();
+        const decrement = desiredLanguages.length < 10 ? 0.1 : 1.0 / desiredLanguages.length;
+        let base = 1.0;
+        // fill any missing fields from the default
+        options = Object.assign(Object.assign({}, defaultLanguageChooserOptions), options);
+        for (const want of desiredLanguages) {
+            base -= decrement;
+            for (const have of availableLanguages) {
+                const similarity = this._matcher.matchLanguageTags(want, have);
+                if (similarity > 0.0) {
+                    const quality = base + similarity * decrement;
+                    const languageTag = options.use === 'availableLanguage' ? have : want;
+                    const tag = languageTag.tag;
+                    const key = options.filter === 'primaryLanguage' ? (_a = languageTag.subtags.primaryLanguage) !== null && _a !== void 0 ? _a : tag : tag;
+                    const match = {
+                        quality,
+                        tag,
+                        languageTag
+                    };
+                    const existing = matched.get(key);
+                    if (!existing || existing.quality < quality) {
+                        matched.set(key, match);
+                    }
+                }
+            }
+        }
+        const values = Array.from(matched.values());
+        if (values.length > 1) {
+            // want descending order
+            values.sort((m1, m2) => m2.quality - m1.quality);
+        }
+        else if (values.length === 0 && options.ultimateFallback) {
+            const languageTag = options.ultimateFallback instanceof LanguageTag
+                ? options.ultimateFallback
+                : LanguageTag.create(options.ultimateFallback).orDefault();
+            if (languageTag) {
+                return [{ languageTag, tag: languageTag.tag, quality: 0 }];
+            }
+        }
+        return values;
+    }
+    filterLanguageTags(desiredLanguages, availableLanguages, options) {
+        return this.chooseLanguageTagsWithDetails(desiredLanguages, availableLanguages, options).map((t) => t.languageTag);
+    }
+}
+//# sourceMappingURL=chooser.js.map

package/dist/packlets/bcp47/match/common.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/* eslint-disable @rushstack/typedef-var */
+/**
+ * Penalty for a mismatched value for some subtags.
+ * @public
+ */
+export const subtagMismatchPenalty = {
+    private: 0.05,
+    extension: 0.04,
+    variant: 0.1
+};
+/**
+ * Common levels of match quality for a single language match.
+ * @public
+ */
+export const tagSimilarity = {
+    exact: 1.0,
+    variant: 0.9,
+    region: 0.8,
+    macroRegion: 0.65,
+    neutralRegion: 0.5,
+    preferredAffinity: 0.45,
+    affinity: 0.4,
+    preferredRegion: 0.35,
+    sibling: 0.3,
+    undetermined: 0.1,
+    none: 0
+};
+//# sourceMappingURL=common.js.map

package/dist/packlets/bcp47/match/index.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+// istanbul ignore file
+export { LanguageChooser } from './chooser';
+export * from './common';
+export { LanguageSimilarityMatcher } from './similarity';
+//# sourceMappingURL=index.js.map

package/dist/packlets/bcp47/match/similarity.js

@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import * as Iana from '../../iana';
+import * as Unsd from '../../unsd';
+import { DefaultRegistries } from '../overrides';
+import { GlobalRegion } from '../common';
+import { tagSimilarity } from './common';
+/**
+ * Helper to compare two language tags to determine how closely related they are,
+ * applying normalization and language semantics as appropriate.
+ * @public
+ */
+export class LanguageSimilarityMatcher {
+    constructor(iana) {
+        /* c8 ignore next */
+        this.iana = iana !== null && iana !== void 0 ? iana : Iana.DefaultRegistries.languageRegistries;
+        this.unsd = Unsd.DefaultRegistries.regionCodes;
+        this.overrides = DefaultRegistries.overridesRegistry;
+    }
+    matchLanguageTags(t1, t2) {
+        // no primary tag is either all private or grandfathered, which must match
+        // exactly.
+        if (!t1.subtags.primaryLanguage || !t2.subtags.primaryLanguage) {
+            return t1.toString().toLowerCase() === t2.toString().toLowerCase()
+                ? tagSimilarity.exact
+                : tagSimilarity.none;
+        }
+        let quality = this.matchPrimaryLanguage(t1, t2);
+        quality = quality > tagSimilarity.none ? Math.min(this.matchExtlang(t1, t2), quality) : quality;
+        quality = quality > tagSimilarity.none ? Math.min(this.matchScript(t1, t2), quality) : quality;
+        quality = quality > tagSimilarity.none ? Math.min(this.matchRegion(t1, t2), quality) : quality;
+        quality = quality > tagSimilarity.none ? Math.min(this.matchVariants(t1, t2), quality) : quality;
+        quality = quality > tagSimilarity.none ? Math.min(this.matchExtensions(t1, t2), quality) : quality;
+        quality = quality > tagSimilarity.none ? Math.min(this.matchPrivateUseTags(t1, t2), quality) : quality;
+        return quality;
+    }
+    matchPrimaryLanguage(lt1, lt2) {
+        var _a, _b;
+        /* c8 ignore next 2 */
+        const l1 = (_a = lt1.subtags.primaryLanguage) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const l2 = (_b = lt2.subtags.primaryLanguage) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        if (l1 === l2) {
+            return tagSimilarity.exact;
+        }
+        if (lt1.isUndetermined || lt2.isUndetermined) {
+            return tagSimilarity.undetermined;
+        }
+        return tagSimilarity.none;
+    }
+    matchExtlang(lt1, lt2) {
+        var _a, _b;
+        if (((_a = lt1.subtags.extlangs) === null || _a === void 0 ? void 0 : _a.length) !== ((_b = lt2.subtags.extlangs) === null || _b === void 0 ? void 0 : _b.length)) {
+            return tagSimilarity.none;
+        }
+        if (lt1.subtags.extlangs) {
+            for (let i = 0; i < lt1.subtags.extlangs.length; i++) {
+                if (lt1.subtags.extlangs[i].toLowerCase() !== lt2.subtags.extlangs[i].toLowerCase()) {
+                    return tagSimilarity.none;
+                }
+            }
+        }
+        return tagSimilarity.exact;
+    }
+    matchScript(lt1, lt2) {
+        var _a, _b;
+        const s1 = (_a = lt1.effectiveScript) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const s2 = (_b = lt2.effectiveScript) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        if (s1 === s2) {
+            return tagSimilarity.exact;
+        }
+        if (lt1.isUndetermined || lt2.isUndetermined) {
+            return tagSimilarity.undetermined;
+        }
+        return tagSimilarity.none;
+    }
+    matchRegion(lt1, lt2) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const r1 = (_a = lt1.subtags.region) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+        const r2 = (_b = lt2.subtags.region) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+        if (r1 === r2) {
+            return tagSimilarity.exact;
+        }
+        // region 001 is equivalent to neutral (no region)
+        if (r1 === GlobalRegion || r2 === GlobalRegion) {
+            // if one tag is 001 and the other in neutral, exact match
+            // otherwise, one tag is 001 so neutral region match
+            return !r1 || !r2 ? tagSimilarity.exact : tagSimilarity.neutralRegion;
+        }
+        if (!r1 || !r2) {
+            return tagSimilarity.neutralRegion;
+        }
+        // macro-region match
+        const r1IsMacroRegion = Iana.Validate.unM49RegionCode.isWellFormed(r1);
+        const r2IsMacroRegion = Iana.Validate.unM49RegionCode.isWellFormed(r2);
+        if (r1IsMacroRegion || r2IsMacroRegion) {
+            let contained;
+            let container;
+            if (r1IsMacroRegion) {
+                container = this.unsd.regions.tryGetRegion(r1);
+                contained =
+                    (_c = this.unsd.areas.tryGetAlpha2Area(r2)) !== null && _c !== void 0 ? _c : this.unsd.tryGetRegionOrArea(r2);
+            }
+            else {
+                container = this.unsd.regions.tryGetRegion(r2);
+                contained = this.unsd.areas.tryGetAlpha2Area(r1);
+            }
+            if (container && contained) {
+                if (this.unsd.getIsContained(container, contained)) {
+                    return tagSimilarity.macroRegion;
+                }
+                // if they're both regions, also check to see if the second region contains the
+                // first
+                if (contained.tier !== 'area' && this.unsd.getIsContained(contained, container)) {
+                    return tagSimilarity.macroRegion;
+                }
+            }
+        }
+        /* c8 ignore next 6 */
+        const o1 = this.overrides.overrides.get((_d = lt1.subtags.primaryLanguage) === null || _d === void 0 ? void 0 : _d.toLowerCase());
+        const o2 = this.overrides.overrides.get((_e = lt2.subtags.primaryLanguage) === null || _e === void 0 ? void 0 : _e.toLowerCase());
+        // orthographic affinity
+        if (o1 && o2) {
+            /* c8 ignore next 2 */
+            const a1 = (_g = (_f = o1.affinity) === null || _f === void 0 ? void 0 : _f.get(r1)) !== null && _g !== void 0 ? _g : o1.defaultAffinity;
+            const a2 = (_j = (_h = o2.affinity) === null || _h === void 0 ? void 0 : _h.get(r2)) !== null && _j !== void 0 ? _j : o2.defaultAffinity;
+            if (a1 && a2) {
+                if (r1 === a2.toUpperCase() || r2 === a1.toUpperCase()) {
+                    return tagSimilarity.preferredAffinity;
+                }
+                if (a1 === a2) {
+                    return tagSimilarity.affinity;
+                }
+            }
+        }
+        // preferred region
+        if ((o1 === null || o1 === void 0 ? void 0 : o1.preferredRegion) === r1 || (o2 === null || o2 === void 0 ? void 0 : o2.preferredRegion) === r2) {
+            return tagSimilarity.preferredRegion;
+        }
+        return tagSimilarity.sibling;
+    }
+    matchVariants(lt1, lt2) {
+        var _a, _b;
+        if (((_a = lt1.subtags.variants) === null || _a === void 0 ? void 0 : _a.length) !== ((_b = lt2.subtags.variants) === null || _b === void 0 ? void 0 : _b.length)) {
+            return tagSimilarity.region;
+        }
+        if (lt1.subtags.variants) {
+            for (let i = 0; i < lt1.subtags.variants.length; i++) {
+                if (lt1.subtags.variants[i].toLowerCase() !== lt2.subtags.variants[i].toLowerCase()) {
+                    return tagSimilarity.region;
+                }
+            }
+        }
+        return tagSimilarity.exact;
+    }
+    matchExtensions(lt1, lt2) {
+        var _a, _b;
+        if (((_a = lt1.subtags.extensions) === null || _a === void 0 ? void 0 : _a.length) !== ((_b = lt2.subtags.extensions) === null || _b === void 0 ? void 0 : _b.length)) {
+            return tagSimilarity.variant;
+        }
+        if (lt1.subtags.extensions) {
+            for (let i = 0; i < lt1.subtags.extensions.length; i++) {
+                if (lt1.subtags.extensions[i].singleton.toLowerCase() !==
+                    lt2.subtags.extensions[i].singleton.toLowerCase() ||
+                    lt1.subtags.extensions[i].value.toLowerCase() !== lt2.subtags.extensions[i].value.toLowerCase()) {
+                    return tagSimilarity.variant;
+                }
+            }
+        }
+        return tagSimilarity.exact;
+    }
+    matchPrivateUseTags(lt1, lt2) {
+        var _a, _b;
+        if (((_a = lt1.subtags.privateUse) === null || _a === void 0 ? void 0 : _a.length) !== ((_b = lt2.subtags.privateUse) === null || _b === void 0 ? void 0 : _b.length)) {
+            return tagSimilarity.variant;
+        }
+        if (lt1.subtags.privateUse) {
+            for (let i = 0; i < lt1.subtags.privateUse.length; i++) {
+                if (lt1.subtags.privateUse[i].toLowerCase() !== lt2.subtags.privateUse[i].toLowerCase()) {
+                    return tagSimilarity.variant;
+                }
+            }
+        }
+        return tagSimilarity.exact;
+    }
+}
+//# sourceMappingURL=similarity.js.map

package/dist/packlets/bcp47/normalization/baseNormalizer.js

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import * as Iana from '../../iana';
+import { allSucceed, fail, mapResults, populateObject, succeed } from '@fgv/ts-utils';
+import { subtagsToString } from '../common';
+/**
+ * @public
+ */
+export class TagNormalizerBase {
+    constructor(iana) {
+        /* c8 ignore next - dependency injection primarily for test */
+        this._iana = iana !== null && iana !== void 0 ? iana : Iana.DefaultRegistries.languageRegistries;
+    }
+    processSubtags(subtags) {
+        return populateObject({
+            primaryLanguage: () => this._processLanguage(subtags),
+            extlangs: () => this._processExtlangs(subtags),
+            script: () => this._processScript(subtags),
+            region: () => this._processRegion(subtags),
+            variants: () => this._processVariants(subtags),
+            extensions: () => this._processExtensions(subtags),
+            privateUse: () => this._processPrivateUseTags(subtags),
+            grandfathered: () => this._processGrandfatheredTags(subtags)
+        }, { suppressUndefined: true }).onSuccess((processed) => {
+            return this._postValidate(processed);
+        });
+    }
+    _basicPostValidation(subtags) {
+        /* c8 ignore next 7 - any validation whatsoever catches these so should never happen in practice */
+        if (subtags.primaryLanguage === undefined &&
+            subtags.grandfathered === undefined &&
+            subtags.privateUse === undefined) {
+            return fail(`${subtagsToString(subtags)}: missing primary language subtag.`);
+        }
+        /* c8 ignore next 3 - any validation whatsoever catches these so should never happen in practice */
+        if (subtags.extlangs && subtags.extlangs.length > 3) {
+            return fail(`${subtagsToString(subtags)}: too many extlang subtags`);
+        }
+        return succeed(subtags);
+    }
+    _postValidate(subtags) {
+        return this._basicPostValidation(subtags);
+    }
+    _processExtensions(subtags) {
+        if (subtags.extensions) {
+            return mapResults(subtags.extensions.map((ex) => {
+                return populateObject({
+                    singleton: () => this._processExtensionSingleton(ex.singleton),
+                    value: () => this._processExtensionSubtagValue(ex.value)
+                });
+            }));
+        }
+        return succeed(subtags.extensions);
+    }
+    _verifyUnique(description, items, getKey) {
+        if (items) {
+            const present = new Set();
+            return allSucceed(items.map((i) => {
+                const key = getKey(i);
+                if (present.has(key)) {
+                    return fail(`${key}: duplicate ${description}`);
+                }
+                present.add(key);
+                return succeed(key);
+            }), items);
+        }
+        return succeed(items);
+    }
+}
+//# sourceMappingURL=baseNormalizer.js.map

package/dist/packlets/bcp47/normalization/canonicalNormalizer.js

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import * as Iana from '../../iana';
+import * as Bcp47Subtags from '../bcp47Subtags';
+import { mapResults, succeed } from '@fgv/ts-utils';
+import { TagNormalizerBase } from './baseNormalizer';
+/**
+ * @internal
+ */
+export class CanonicalNormalizer extends TagNormalizerBase {
+    constructor() {
+        super(...arguments);
+        this.normalization = 'canonical';
+    }
+    _processLanguage(subtags) {
+        if (subtags.primaryLanguage) {
+            return this._iana.subtags.languages.toCanonical(subtags.primaryLanguage);
+        }
+        return succeed(subtags.primaryLanguage);
+    }
+    _processExtlangs(subtags) {
+        if (subtags.extlangs) {
+            return mapResults(subtags.extlangs.map((e) => this._iana.subtags.extlangs.toCanonical(e)));
+        }
+        return succeed(undefined);
+    }
+    _processScript(subtags) {
+        if (subtags.script) {
+            return this._iana.subtags.scripts.toCanonical(subtags.script);
+        }
+        return succeed(undefined);
+    }
+    _processRegion(subtags) {
+        if (subtags.region) {
+            return this._iana.subtags.regions.toCanonical(subtags.region);
+        }
+        return succeed(undefined);
+    }
+    _processVariants(subtags) {
+        if (subtags.variants) {
+            return mapResults(subtags.variants.map((v) => this._iana.subtags.variants.toCanonical(v)));
+        }
+        return succeed(undefined);
+    }
+    _processExtensionSingleton(singleton) {
+        return this._iana.extensions.extensions.toCanonical(singleton);
+    }
+    _processExtensionSubtagValue(value) {
+        return Bcp47Subtags.Validate.extensionSubtag.toCanonical(value);
+    }
+    _processPrivateUseTags(subtags) {
+        if (subtags.privateUse) {
+            const merged = subtags.privateUse.join('-');
+            return Iana.LanguageSubtags.Validate.extendedLanguageRange.toCanonical(merged).onSuccess((canon) => {
+                return succeed(canon.split('-'));
+            });
+        }
+        return succeed(subtags.privateUse);
+    }
+    _processGrandfatheredTags(subtags) {
+        if (subtags.grandfathered) {
+            return this._iana.subtags.grandfathered.toCanonical(subtags.grandfathered);
+        }
+        return succeed(undefined);
+    }
+}
+//# sourceMappingURL=canonicalNormalizer.js.map

package/dist/packlets/bcp47/normalization/common.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Ordered ranking of the degrees of normalization, from `unknown` (least
+ * normalized) to `preferred` (most normalized).
+ * @public
+ */
+const normalizationRank = {
+    /**
+     * Normalization level is unknown.
+     */
+    unknown: 0,
+    /**
+     * Not normalized.
+     */
+    none: 0.1,
+    /**
+     * Tag and subtag case has been normalized to canonical
+     * letter case (e.g. lower-case language and upper-case
+     * region) but no other normalization has been applied.
+     */
+    canonical: 0.9,
+    /**
+     * All tag recommendations have been applied - e.g. suppressed
+     * script is removed, deprecated or grandfathered values are
+     * replaced with preferred values.
+     */
+    preferred: 1.0
+};
+/**
+ * Determines which of two normalization ranks is most normalized.
+ * @param n1 - The first {@link TagNormalization} to be compared.
+ * @param n2 - The second {@link TagNormalization} to me compared.
+ * @returns `1` if `n1` is more normalized, `-1` if `n2` is more
+ * normalized, or `0` if they are identical.
+ * @public
+ */
+export function compareNormalization(n1, n2) {
+    if (normalizationRank[n1] > normalizationRank[n2]) {
+        return 1;
+    }
+    else if (normalizationRank[n1] < normalizationRank[n2]) {
+        return -1;
+    }
+    return 0;
+}
+/**
+ * Chooses the most normalized of two normalization ranks.
+ * @param n1 - The first {@link TagNormalization} to be compared.
+ * @param n2 - The second {@link TagNormalization} to me compared.
+ * @returns The most normalized of `n1` or `n2`.
+ * @public
+ */
+export function mostNormalized(n1, n2) {
+    /* c8 ignore next - hard to hit due to guards */
+    return normalizationRank[n1] > normalizationRank[n2] ? n1 : n2;
+}
+//# sourceMappingURL=common.js.map

package/dist/packlets/bcp47/normalization/index.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+// istanbul ignore file
+export * from './common';
+export { NormalizeTag } from './normalizeTag';
+export { CanonicalNormalizer } from './canonicalNormalizer';
+export { PreferredNormalizer } from './preferredTagNormalizer';
+//# sourceMappingURL=index.js.map