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

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

@@ -0,0 +1,101 @@
+/*
+ * 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 { succeed } from '@fgv/ts-utils';
+import { compareNormalization } from './common';
+import { CanonicalNormalizer } from './canonicalNormalizer';
+import { PreferredNormalizer } from './preferredTagNormalizer';
+/**
+ * Normalization helpers for BCP-47 language tags.
+ * @public
+ */
+export class NormalizeTag {
+    /**
+     * Converts a BCP-47 language tag to canonical form.  Canonical form uses the recommended capitalization rules
+     * specified in {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | RFC 5646} but are not
+     * otherwise modified.
+     *
+     * @param subtags - The individual {@link Bcp47.Subtags | subtags} to be normalized.
+     * @returns `Success` with the normalized equivalent {@link Bcp47.Subtags | subtags},
+     * or `Failure` with details if an error occurs.
+     */
+    static toCanonical(subtags) {
+        return this.normalizeSubtags(subtags, 'canonical');
+    }
+    /**
+     * Converts a BCP-47 language tag to preferred form.  Preferred form uses the recommended capitalization rules
+     * specified in {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | RFC 5646} and also
+     * applies additional preferred values specified in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry}:
+     * extraneous (suppressed) script tags are removed, deprecated language, extlang, script or region tags are replaced
+     * with up-to-date preferred values, and grandfathered or redundant tags with a defined preferred-value are replaced
+     * in their entirety with the new preferred value.
+     * @param subtags - The individual {@link Bcp47.Subtags | subtags} to be normalized.
+     * @returns `Success` with the normalized equivalent {@link Bcp47.Subtags | subtags},
+     * or `Failure` with details if an error occurs.
+     */
+    static toPreferred(subtags) {
+        return this.normalizeSubtags(subtags, 'preferred');
+    }
+    /**
+     * Chooses an appropriate default tag normalizer given desired and optional current
+     * {@link Bcp47.TagNormalization | normalization level}.
+     * @param wantNormalization - The desired {@link Bcp47.TagNormalization | normalization level}.
+     * @param haveNormalization - (optional) The current {@link Bcp47.TagNormalization | normalization level}.
+     * @returns An appropriate {@link Bcp47.TagNormalizer | tag normalizer} or `undefined` if no additional
+     * normalization is necessary.
+     * @internal
+     */
+    static chooseNormalizer(wantNormalization, haveNormalization) {
+        if (haveNormalization && compareNormalization(haveNormalization, wantNormalization) >= 0) {
+            return undefined;
+        }
+        if (!this._normalizers) {
+            this._normalizers = {
+                unknown: undefined,
+                none: undefined,
+                canonical: new CanonicalNormalizer(),
+                preferred: new PreferredNormalizer()
+            };
+        }
+        return this._normalizers[wantNormalization];
+    }
+    /**
+     * Normalizes supplied {@link Bcp47.Subtags | subtags} to a requested
+     * {@link Bcp47.TagNormalization | normalization level}, if necessary.  If
+     * no normalization is necessary, returns the supplied subtags.
+     * @param subtags - The {@link Bcp47.Subtags | subtags} to be normalized.
+     * @param wantNormalization - The desired {@link Bcp47.TagNormalization | normalization level}.
+     * @param haveNormalization - (optional) The current {@link Bcp47.TagNormalization | normalization level}.
+     * @returns `Success` with the normalized {@link Bcp47.Subtags | subtags}, or
+     * `Failure` with details if an error occurs.
+     */
+    static normalizeSubtags(subtags, wantNormalization, haveNormalization) {
+        var _a;
+        const normalizer = this.chooseNormalizer(wantNormalization, haveNormalization);
+        return (_a = normalizer === null || normalizer === void 0 ? void 0 : normalizer.processSubtags(subtags)) !== null && _a !== void 0 ? _a : succeed(subtags);
+    }
+}
+/**
+ * @internal
+ */
+NormalizeTag._normalizers = undefined;
+//# sourceMappingURL=normalizeTag.js.map

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

@@ -0,0 +1,177 @@
+/*
+ * 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 { fail, mapResults, succeed } from '@fgv/ts-utils';
+import { subtagsToString } from '../common';
+import { sanitizeJson } from '../../utils';
+import { LanguageTagParser } from '../languageTagParser';
+import { TagNormalizerBase } from './baseNormalizer';
+/**
+ * @public
+ */
+export class PreferredNormalizer extends TagNormalizerBase {
+    constructor() {
+        super(...arguments);
+        this.normalization = 'preferred';
+    }
+    _processLanguage(subtags) {
+        var _a;
+        if (subtags.primaryLanguage) {
+            const language = this._iana.subtags.languages.tryGet(subtags.primaryLanguage);
+            if (!language) {
+                return fail(`invalid language subtag "${subtags.primaryLanguage}"`);
+            }
+            return succeed((_a = language.preferredValue) !== null && _a !== void 0 ? _a : language.subtag);
+        }
+        return succeed(undefined);
+    }
+    _processExtlangs(subtags) {
+        if (subtags.extlangs) {
+            return mapResults(subtags.extlangs.map((e) => this._iana.subtags.extlangs.toValidCanonical(e)));
+        }
+        return succeed(undefined);
+    }
+    _processScript(subtags) {
+        if (subtags.primaryLanguage && subtags.script) {
+            const language = this._iana.subtags.languages.tryGet(subtags.primaryLanguage);
+            /* c8 ignore next 3 - internal error difficult to test */
+            if (!language) {
+                return fail(`invalid primary language subtag "${subtags.primaryLanguage}.`);
+            }
+            const script = this._iana.subtags.scripts.toValidCanonical(subtags.script).orDefault();
+            if (!script) {
+                return fail(`invalid script subtag "${subtags.script}`);
+            }
+            if (language.suppressScript !== script) {
+                return succeed(script);
+            }
+        }
+        return succeed(undefined);
+    }
+    _processRegion(subtags) {
+        if (subtags.region) {
+            return this._iana.subtags.regions.get(subtags.region).onSuccess((region) => {
+                var _a;
+                return succeed((_a = region.preferredValue) !== null && _a !== void 0 ? _a : region.subtag);
+            });
+        }
+        return succeed(undefined);
+    }
+    _processVariants(subtags) {
+        if (subtags.variants) {
+            return mapResults(subtags.variants.map((v) => this._iana.subtags.variants.toValidCanonical(v))).onSuccess((v) => this._verifyUnique('variant', v, (v) => v));
+        }
+        return succeed(undefined);
+    }
+    _processExtensionSingleton(singleton) {
+        return this._iana.extensions.extensions.toValidCanonical(singleton);
+    }
+    _processExtensionSubtagValue(value) {
+        return Bcp47Subtags.Validate.extensionSubtag.toCanonical(value);
+    }
+    _processExtensions(subtags) {
+        return super._processExtensions(subtags).onSuccess((extensions) => {
+            return this._verifyUnique('extensions', extensions, (e) => e.singleton);
+        });
+    }
+    _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(undefined);
+    }
+    _processGrandfatheredTags(subtags) {
+        if (subtags.grandfathered) {
+            return this._iana.subtags.grandfathered.toValidCanonical(subtags.grandfathered);
+        }
+        return succeed(undefined);
+    }
+    _postValidateGrandfatheredTag(subtags) {
+        if (subtags.grandfathered) {
+            return this._iana.subtags.grandfathered.get(subtags.grandfathered).onSuccess((grandfathered) => {
+                if (grandfathered.preferredValue) {
+                    return LanguageTagParser.parse(grandfathered.preferredValue, this._iana)
+                        .onSuccess((gfSubtags) => {
+                        /* c8 ignore next 5 - would require a registry error too hard to test */
+                        if (gfSubtags.grandfathered !== undefined) {
+                            return fail(`preferred value ${grandfathered.preferredValue} of grandfathered tag ${subtags.grandfathered} is also grandfathered.`);
+                        }
+                        return this.processSubtags(gfSubtags);
+                    })
+                        .onFailure((message) => {
+                        /* c8 ignore next 4 - would require a registry error too hard to test */
+                        return fail(`grandfathered tag "${subtags.grandfathered}" has invalid preferred value "${grandfathered.preferredValue}":\n${message}`);
+                    });
+                }
+                return succeed(subtags);
+            });
+        }
+        return succeed(subtags);
+    }
+    _postValidateRedundantTag(subtags) {
+        const tag = subtagsToString(subtags);
+        const redundant = this._iana.subtags.redundant.tryGetCanonical(tag);
+        if (redundant === null || redundant === void 0 ? void 0 : redundant.preferredValue) {
+            return LanguageTagParser.parse(redundant.preferredValue, this._iana);
+        }
+        return succeed(subtags);
+    }
+    _postValidateExtLangs(subtags) {
+        var _a;
+        if (subtags.extlangs) {
+            if (subtags.extlangs.length > 1) {
+                return fail(`${subtags.extlangs.join('-')}: multiple extlang subtags is invalid`);
+            }
+            if (subtags.extlangs.length > 0) {
+                const registry = this._iana.subtags.extlangs.tryGet(subtags.extlangs[0]);
+                if (registry) {
+                    if (registry.preferredValue &&
+                        registry.prefix === /* c8 ignore next */ ((_a = subtags.primaryLanguage) === null || _a === void 0 ? void 0 : _a.toLowerCase())) {
+                        const preferred = this._iana.subtags.languages.tryGet(registry.preferredValue);
+                        if (preferred) {
+                            return succeed(sanitizeJson(Object.assign(Object.assign({}, subtags), { primaryLanguage: preferred.subtag, extlangs: undefined })));
+                        }
+                    }
+                }
+            }
+        }
+        return succeed(subtags);
+    }
+    _postValidate(subtags) {
+        return super
+            ._postValidate(subtags)
+            .onSuccess((subtags) => {
+            return this._postValidateExtLangs(subtags);
+        })
+            .onSuccess((subtags) => {
+            return this._postValidateGrandfatheredTag(subtags);
+        })
+            .onSuccess((subtags) => {
+            return this._postValidateRedundantTag(subtags);
+        });
+    }
+}
+//# sourceMappingURL=preferredTagNormalizer.js.map

package/dist/packlets/bcp47/overrides/converters.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 */
+import * as Iana from '../../iana';
+import { JsonFile } from '@fgv/ts-json-base';
+import { Converters } from '@fgv/ts-utils';
+/**
+ * @internal
+ */
+export const languageOverrideRecord = Converters.strictObject({
+    language: Iana.LanguageSubtags.Converters.Tags.languageSubtag,
+    preferredRegion: Iana.LanguageSubtags.Converters.Tags.regionSubtag,
+    defaultAffinity: Converters.string,
+    affinity: Converters.recordOf(Converters.arrayOf(Iana.LanguageSubtags.Converters.Tags.regionSubtag))
+}, { optionalFields: ['affinity', 'defaultAffinity', 'preferredRegion'] });
+/**
+ * @internal
+ */
+export const languageOverridesFile = Converters.arrayOf(languageOverrideRecord);
+/**
+ * Loads a language overrides JSON file.
+ * @internal
+ * @param path - Path from which overrides should be loaded.
+ * @returns `Success` with the loaded overrides or `Failure` with details if an
+ * error occurs.
+ */
+export function loadLanguageOverridesFileSync(path) {
+    return JsonFile.convertJsonFileSync(path, languageOverridesFile);
+}
+//# sourceMappingURL=converters.js.map

package/dist/packlets/bcp47/overrides/defaultRegistries.js

@@ -0,0 +1,38 @@
+/*
+ * 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 { OverridesRegistry } from './overridesRegistry';
+/**
+ * @public
+ */
+export class DefaultRegistries {
+    static get overridesRegistry() {
+        if (!this._overridesRegistry) {
+            this._overridesRegistry = OverridesRegistry.loadDefault().orThrow();
+        }
+        return this._overridesRegistry;
+    }
+}
+/**
+ * @internal
+ */
+DefaultRegistries._overridesRegistry = undefined;
+//# sourceMappingURL=defaultRegistries.js.map

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

@@ -0,0 +1,25 @@
+/*
+ * 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 { OverridesRegistry } from './overridesRegistry';
+export { DefaultRegistries } from './defaultRegistries';
+//# sourceMappingURL=index.js.map

package/dist/packlets/bcp47/overrides/model.js

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=model.js.map

package/dist/packlets/bcp47/overrides/overridesRegistry.js

@@ -0,0 +1,83 @@
+/*
+ * 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 Converters from './converters';
+import { mapResults, succeed } from '@fgv/ts-utils';
+// eslint-disable-next-line @rushstack/packlets/mechanics
+import defaultOverrides from '../../../data/bcp/overrides.json';
+/**
+ * @public
+ */
+export class OverridesRegistry {
+    constructor() {
+        this.overrides = new Map();
+    }
+    static create(overrides) {
+        const registry = new OverridesRegistry();
+        overrides.forEach((o) => registry.overrides.set(o.language, o));
+        return succeed(registry);
+    }
+    static createFromJson(from) {
+        return Converters.languageOverridesFile
+            .convert(from)
+            .onSuccess((records) => {
+            return mapResults(records.map(OverridesRegistry._overrideFromRecord));
+        })
+            .onSuccess((overrides) => {
+            return OverridesRegistry.create(overrides);
+        });
+    }
+    static loadDefault() {
+        return this.createFromJson(defaultOverrides);
+    }
+    static loadJson(path) {
+        return Converters.loadLanguageOverridesFileSync(path).onSuccess(OverridesRegistry.createFromJson);
+    }
+    /**
+     * Converts a file {@link Bcp47.Overrides.Model.LanguageOverrideRecord | LanguageOverrideRecord }
+     * to a runtime {@link Bcp47.Overrides.LanguageOverride | LanguageOverride}.
+     * @param record - The {@link Bcp47.Overrides.Model.LanguageOverrideRecord | LanguageOverrideRecord } to
+     * be converted.
+     * @returns `Success` with the resulting {@link Bcp47.Overrides.LanguageOverride | LanguageOverride}
+     * or `Error` with details if an error occurs.
+     * @internal
+     */
+    static _overrideFromRecord(record) {
+        const override = { language: record.language };
+        if (record.preferredRegion) {
+            override.preferredRegion = record.preferredRegion;
+        }
+        if (record.defaultAffinity) {
+            override.defaultAffinity = record.defaultAffinity;
+        }
+        if (record.affinity) {
+            const affinity = new Map();
+            for (const kvp of Object.entries(record.affinity)) {
+                for (const region of kvp[1]) {
+                    affinity.set(region, kvp[0]);
+                }
+            }
+            override.affinity = affinity;
+        }
+        return succeed(override);
+    }
+}
+//# sourceMappingURL=overridesRegistry.js.map

package/dist/packlets/bcp47/validation/baseValidator.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 { allSucceed, fail, succeed } from '@fgv/ts-utils';
+import { subtagsToString } from '../common';
+/**
+ * @internal
+ */
+export class TagValidatorBase {
+    constructor(iana) {
+        /* c8 ignore next */
+        this.iana = iana !== null && iana !== void 0 ? iana : Iana.DefaultRegistries.languageRegistries;
+    }
+    validateSubtags(subtags) {
+        return allSucceed([
+            this._checkLanguage(subtags),
+            this._checkExtlangs(subtags),
+            this._checkScript(subtags),
+            this._checkRegion(subtags),
+            this._checkVariants(subtags),
+            this._checkExtensions(subtags),
+            this._checkPrivateUseTags(subtags),
+            this._checkGrandfatheredTags(subtags)
+        ], true).onSuccess(() => {
+            return this._postValidate(subtags).onSuccess(() => succeed(true));
+        });
+    }
+    _basicPostValidation(subtags) {
+        if (subtags.primaryLanguage === undefined &&
+            subtags.grandfathered === undefined &&
+            subtags.privateUse === undefined) {
+            return fail(`${subtagsToString(subtags)}: missing primary language subtag.`);
+        }
+        if (subtags.extlangs && subtags.extlangs.length > 3) {
+            return fail(`${subtagsToString(subtags)}: too many extlang subtags`);
+        }
+        return succeed(subtags);
+    }
+    _postValidate(subtags) {
+        return this._basicPostValidation(subtags);
+    }
+    _checkExtensions(subtags) {
+        if (subtags.extensions) {
+            return allSucceed(subtags.extensions.map((ext) => {
+                return this._checkExtensionSingleton(ext.singleton).onSuccess(() => {
+                    return this._checkExtensionSubtagValue(ext.value);
+                });
+            }), subtags.extensions);
+        }
+        return succeed(undefined);
+    }
+    _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=baseValidator.js.map

package/dist/packlets/bcp47/validation/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 validity, from `unknown` (least
+ * validation) to `strictly-valid` (fully validated).
+ * @public
+ */
+const validityRank = {
+    /**
+     * No validation has been performed.
+     */
+    unknown: 0,
+    /**
+     * Tag is well-formed {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | according to RFC 5646}.
+     */
+    'well-formed': 0.5,
+    /**
+     * Tag is valid {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | according to RFC 5646} -
+     * well-formed, and is a registered grandfathered tag or all subtags are registered,
+     * with no duplicate extensions or variant subtags.
+     */
+    valid: 0.9,
+    /**
+     * Tag is valid {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | according to RFC 5646} and meets
+     * other constraints described by the RFC - e.g. if present, any extlang or variant subtags have a
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | valid prefix} as specified by
+     * the registry.
+     */
+    'strictly-valid': 1.0
+};
+/**
+ * Determines which of two validity ranks is most normalized.
+ * @param v1 - The first {@link TagValidity} to be compared.
+ * @param v2 - The second {@link TagValidity} to be compared.
+ * @returns `1` if `v1` is more normalized, `-1` if `v2` is more
+ * normalized, or `0` if they are identical.
+ * @public
+ */
+export function compareValidity(v1, v2) {
+    if (validityRank[v1] > validityRank[v2]) {
+        return 1;
+    }
+    else if (validityRank[v1] < validityRank[v2]) {
+        return -1;
+    }
+    return 0;
+}
+/**
+ * Chooses the most valid of two normalization ranks.
+ * @param v1 - The first {@link TagValidity} to be compared.
+ * @param v2 - The second {@link TagValidity} to be compared.
+ * @returns The most validated of `v1` or `v2`.
+ * @public
+ */
+export function mostValid(v1, v2) {
+    return validityRank[v1] >= validityRank[v2] ? v1 : v2;
+}
+//# sourceMappingURL=common.js.map