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

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

@@ -0,0 +1,29 @@
+/*
+ * 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 { IsCanonicalValidator } from './isCanonical';
+export { IsStrictlyValidValidator } from './isStrictlyValid';
+export { IsValidValidator } from './isValid';
+export { IsWellFormedValidator } from './isWellFormed';
+export { ValidateTag } from './validateTag';
+//# sourceMappingURL=index.js.map

package/dist/packlets/bcp47/validation/isCanonical.js

@@ -0,0 +1,79 @@
+/*
+ * 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 { allSucceed, fail, succeed } from '@fgv/ts-utils';
+import { TagValidatorBase } from './baseValidator';
+/**
+ * @internal
+ */
+export class IsCanonicalValidator extends TagValidatorBase {
+    constructor() {
+        super(...arguments);
+        this.validity = 'well-formed';
+    }
+    _checkLanguage(subtags) {
+        if (subtags.primaryLanguage) {
+            return this.iana.subtags.languages.verifyIsCanonical(subtags.primaryLanguage);
+        }
+        return succeed(undefined);
+    }
+    _checkExtlangs(subtags) {
+        if (subtags.extlangs) {
+            return allSucceed(subtags.extlangs.map((e) => this.iana.subtags.extlangs.verifyIsCanonical(e)), subtags.extlangs);
+        }
+        return succeed(undefined);
+    }
+    _checkScript(subtags) {
+        return subtags.script ? this.iana.subtags.scripts.verifyIsCanonical(subtags.script) : succeed(undefined);
+    }
+    _checkRegion(subtags) {
+        return subtags.region ? this.iana.subtags.regions.verifyIsCanonical(subtags.region) : succeed(undefined);
+    }
+    _checkVariants(subtags) {
+        if (subtags.variants) {
+            return allSucceed(subtags.variants.map((v) => this.iana.subtags.variants.verifyIsCanonical(v)), subtags.variants);
+        }
+        return succeed(undefined);
+    }
+    _checkExtensionSingleton(singleton) {
+        return this.iana.extensions.extensions.verifyIsCanonical(singleton);
+    }
+    _checkExtensionSubtagValue(value) {
+        return Bcp47Subtags.Validate.extensionSubtag.verifyIsCanonical(value);
+    }
+    _checkPrivateUseTags(subtags) {
+        if (subtags.privateUse) {
+            const result = Iana.LanguageSubtags.Validate.extendedLanguageRange.verifyIsCanonical(subtags.privateUse.join('-'));
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+        }
+        return succeed(subtags.privateUse);
+    }
+    _checkGrandfatheredTags(subtags) {
+        return subtags.grandfathered
+            ? this.iana.subtags.grandfathered.verifyIsCanonical(subtags.grandfathered)
+            : succeed(undefined);
+    }
+}
+//# sourceMappingURL=isCanonical.js.map

package/dist/packlets/bcp47/validation/isInPreferredForm.js

@@ -0,0 +1,46 @@
+/*
+ * 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 { fail, succeed } from '@fgv/ts-utils';
+import { subtagsToString } from '../common';
+import { NormalizeTag } from '../normalization';
+/**
+ * @internal
+ */
+export class IsInPreferredFromValidator {
+    constructor(iana) {
+        this.validity = 'valid';
+        /* c8 ignore next */
+        this.iana = iana !== null && iana !== void 0 ? iana : Iana.DefaultRegistries.languageRegistries;
+    }
+    validateSubtags(subtags) {
+        return NormalizeTag.toPreferred(subtags).onSuccess((preferred) => {
+            const want = subtagsToString(preferred);
+            const have = subtagsToString(subtags);
+            if (want !== have) {
+                return fail(`${have}: does not match preferred form ${want}`);
+            }
+            return succeed(true);
+        });
+    }
+}
+//# sourceMappingURL=isInPreferredForm.js.map

package/dist/packlets/bcp47/validation/isStrictlyValid.js

@@ -0,0 +1,94 @@
+/*
+ * 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 { fail, mapResults, succeed } from '@fgv/ts-utils';
+import { subtagsToString } from '../common';
+import { NormalizeTag } from '../normalization';
+import { IsValidValidator } from './isValid';
+/**
+ * @internal
+ */
+export class IsStrictlyValidValidator extends IsValidValidator {
+    constructor() {
+        super(...arguments);
+        this.validity = 'strictly-valid';
+        this.normalization = 'unknown';
+    }
+    _checkExtlangs(subtags) {
+        if (subtags.extlangs) {
+            return super._checkExtlangs(subtags).onSuccess(() => this._validateExtlangPrefix(subtags));
+        }
+        return succeed(undefined);
+    }
+    _checkVariants(subtags) {
+        if (subtags.variants) {
+            return super._checkVariants(subtags).onSuccess((v) => this._validateVariantPrefix(subtags, v));
+        }
+        return succeed(undefined);
+    }
+    _validateExtlangPrefix(subtags) {
+        if (subtags.extlangs) {
+            const prefix = this.iana.subtags.languages.toCanonical(subtags.primaryLanguage).orDefault();
+            if (!prefix) {
+                return fail('missing primary language for extlang prefix validation.');
+            }
+            return mapResults(subtags.extlangs.map((extlang) => {
+                const def = this.iana.subtags.extlangs.tryGet(extlang);
+                /* c8 ignore next 3 - should never happen due to guards earlier in conversion */
+                if (!def) {
+                    return fail(`invalid extlang subtag "${extlang}" (not registered).`);
+                }
+                if (prefix !== def.prefix) {
+                    return fail(`invalid prefix "${prefix}" for extlang subtag ${extlang} (expected "${def.prefix}").`);
+                }
+                return succeed(extlang);
+            }));
+        }
+        /* c8 ignore next 2 - should be caught in the caller */
+        return succeed(undefined);
+    }
+    _validateVariantPrefix(subtags, variants) {
+        const { primaryLanguage, extlangs, script, region } = subtags;
+        const nonCanonical = { primaryLanguage, extlangs, script, region };
+        const canonical = NormalizeTag.normalizeSubtags(nonCanonical, 'canonical');
+        /* c8 ignore next 3 - should be caught in the first pass */
+        if (canonical.isFailure()) {
+            return fail(`failed to normalize variant prefix: ${canonical.message}`);
+        }
+        let prefix = subtagsToString(canonical.value);
+        return mapResults(variants.map((variant) => {
+            var _a;
+            const def = this.iana.subtags.variants.tryGet(variant);
+            /* c8 ignore next 3 - should be caught in the first pass */
+            if (!def) {
+                return fail(`invalid variant subtag "${variant}" (not registered).`);
+            }
+            // only fail if registration specifies prefixes but none are present
+            if (((_a = def.prefix) === null || _a === void 0 ? void 0 : _a.includes(prefix)) === false) {
+                return fail(`invalid prefix "${prefix}" for variant subtag ${variant} (expected "(${def.prefix.join(', ')})").`);
+            }
+            const canonicalVariant = this.iana.subtags.variants.toCanonical(variant).orDefault();
+            prefix = `${prefix}-${canonicalVariant}`;
+            return succeed(variant);
+        }));
+    }
+}
+//# sourceMappingURL=isStrictlyValid.js.map

package/dist/packlets/bcp47/validation/isValid.js

@@ -0,0 +1,92 @@
+/*
+ * 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 { allSucceed, fail, mapResults, succeed } from '@fgv/ts-utils';
+import { TagValidatorBase } from './baseValidator';
+/**
+ * @internal
+ */
+export class IsValidValidator extends TagValidatorBase {
+    constructor() {
+        super(...arguments);
+        this.validity = 'valid';
+    }
+    _checkLanguage(subtags) {
+        return subtags.primaryLanguage
+            ? this.iana.subtags.languages.verifyIsValid(subtags.primaryLanguage)
+            : succeed(undefined);
+    }
+    _checkExtlangs(subtags) {
+        if (subtags.extlangs) {
+            return allSucceed(subtags.extlangs.map((e) => this.iana.subtags.extlangs.verifyIsValid(e)), subtags.extlangs);
+        }
+        return succeed(undefined);
+    }
+    _checkScript(subtags) {
+        return subtags.script ? this.iana.subtags.scripts.verifyIsValid(subtags.script) : succeed(undefined);
+    }
+    _checkRegion(subtags) {
+        return subtags.region ? this.iana.subtags.regions.verifyIsValid(subtags.region) : succeed(undefined);
+    }
+    _checkVariants(subtags) {
+        if (subtags.variants) {
+            return allSucceed(subtags.variants.map((v) => this.iana.subtags.variants.verifyIsValid(v)), subtags.variants).onSuccess((v) => {
+                return mapResults(v.map((vc) => this.iana.subtags.variants.toCanonical(vc))).onSuccess((canonical) => {
+                    return this._verifyUnique('variant subtag', canonical, (v) => v);
+                });
+            });
+        }
+        return succeed(undefined);
+    }
+    _checkExtensionSingleton(singleton) {
+        return this.iana.extensions.extensions.verifyIsValid(singleton);
+    }
+    _checkExtensionSubtagValue(value) {
+        return Bcp47Subtags.Validate.extensionSubtag.verifyIsWellFormed(value);
+    }
+    _checkExtensions(subtags) {
+        return super._checkExtensions(subtags).onSuccess((extensions) => {
+            return this._verifyUnique('extensions', extensions, (e) => e.singleton.toLowerCase());
+        });
+    }
+    _checkPrivateUseTags(subtags) {
+        if (subtags.privateUse) {
+            return allSucceed(subtags.privateUse.map((pu) => Iana.LanguageSubtags.Validate.extendedLanguageRange.verifyIsWellFormed(pu)), subtags.privateUse);
+        }
+        return succeed(subtags.privateUse);
+    }
+    _checkGrandfatheredTags(subtags) {
+        return subtags.grandfathered
+            ? this.iana.subtags.grandfathered.verifyIsValid(subtags.grandfathered)
+            : succeed(undefined);
+    }
+    _postValidate(subtags) {
+        return this._basicPostValidation(subtags).onSuccess((validated) => {
+            if (validated.extlangs && validated.extlangs.length > 1) {
+                return fail(`${validated.extlangs.join('-')}: multiple extlang subtags is invalid`);
+            }
+            return succeed(validated);
+        });
+    }
+}
+//# sourceMappingURL=isValid.js.map

package/dist/packlets/bcp47/validation/isWellFormed.js

@@ -0,0 +1,75 @@
+/*
+ * 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 { allSucceed, succeed } from '@fgv/ts-utils';
+import { TagValidatorBase } from './baseValidator';
+/**
+ * @internal
+ */
+export class IsWellFormedValidator extends TagValidatorBase {
+    constructor() {
+        super(...arguments);
+        this.validity = 'well-formed';
+    }
+    _checkLanguage(subtags) {
+        return subtags.primaryLanguage
+            ? this.iana.subtags.languages.verifyIsWellFormed(subtags.primaryLanguage)
+            : succeed(undefined);
+    }
+    _checkExtlangs(subtags) {
+        if (subtags.extlangs) {
+            return allSucceed(subtags.extlangs.map((e) => this.iana.subtags.extlangs.verifyIsWellFormed(e)), subtags.extlangs);
+        }
+        return succeed(undefined);
+    }
+    _checkScript(subtags) {
+        return subtags.script ? this.iana.subtags.scripts.verifyIsWellFormed(subtags.script) : succeed(undefined);
+    }
+    _checkRegion(subtags) {
+        return subtags.region ? this.iana.subtags.regions.verifyIsWellFormed(subtags.region) : succeed(undefined);
+    }
+    _checkVariants(subtags) {
+        if (subtags.variants) {
+            return allSucceed(subtags.variants.map((v) => this.iana.subtags.variants.verifyIsWellFormed(v)), subtags.variants);
+        }
+        return succeed(undefined);
+    }
+    _checkExtensionSingleton(singleton) {
+        return this.iana.extensions.extensions.verifyIsWellFormed(singleton);
+    }
+    _checkExtensionSubtagValue(value) {
+        return Bcp47Subtags.Validate.extensionSubtag.verifyIsWellFormed(value);
+    }
+    _checkPrivateUseTags(subtags) {
+        if (subtags.privateUse) {
+            return allSucceed(subtags.privateUse.map((pu) => Iana.LanguageSubtags.Validate.extendedLanguageRange.verifyIsWellFormed(pu)), subtags.privateUse);
+        }
+        return succeed(subtags.privateUse);
+    }
+    _checkGrandfatheredTags(subtags) {
+        return subtags.grandfathered
+            ? this.iana.subtags.grandfathered.verifyIsWellFormed(subtags.grandfathered)
+            : succeed(undefined);
+    }
+}
+//# sourceMappingURL=isWellFormed.js.map

package/dist/packlets/bcp47/validation/validateTag.js

@@ -0,0 +1,153 @@
+/*
+ * 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 { compareValidity } from './common';
+import { IsCanonicalValidator } from './isCanonical';
+import { IsInPreferredFromValidator } from './isInPreferredForm';
+import { IsStrictlyValidValidator } from './isStrictlyValid';
+import { IsValidValidator } from './isValid';
+import { IsWellFormedValidator } from './isWellFormed';
+/**
+ * Validation helpers for BCP-47 language tags.
+ * @public
+ */
+export class ValidateTag {
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are in canonical form,
+     * meaning that they are at least well-formed as specified by
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646}, and
+     * all subtags are also
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | capitalized as recommended}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a language tag in canonical, false otherwise.
+     * @example `en-US` is in canonical form, `en-us` is not.
+     * @example `eng-US` is in canonical form, `eng-us` is not.
+     */
+    static isCanonical(subtags) {
+        if (!this._isCanonical) {
+            this._isCanonical = new IsCanonicalValidator();
+        }
+        return this._isCanonical.validateSubtags(subtags).isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * in preferred form. Preferred form is valid as specified by
+     * {@link  https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646} and
+     * also meets additional preferences specified in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry} -
+     * extraneous (suppressed) script tags, deprecated language, extlang, script or region tags or
+     * deprecated grandfathered or redundant tags (with a defined preferred-value) are not allowed.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag in preferred form, false otherwise.
+     * @example `en-US` is in preferred form, `en-Latn-US` is not.
+     * @example `cmn` is in preferred form, `zh-cmn-Hans` is not.
+     */
+    static isInPreferredForm(subtags) {
+        if (!this._isInPreferredForm) {
+            this._isInPreferredForm = new IsInPreferredFromValidator();
+        }
+        return this._isInPreferredForm.validateSubtags(subtags).isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * strictly valid.  A strictly valid tag is both
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | valid as defined in the RFC}
+     * and meets any other requirements such as
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | prefix validity}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a strictly valid language tag, false otherwise.
+     * @example `ca-valencia` is strictly valid, `es-valencia` is not.
+     */
+    static isStrictlyValid(subtags) {
+        return this.validateSubtags(subtags, 'strictly-valid').isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * valid as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags, or the tag itself for grandfathered tags, are defined in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA language subtag registry}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag, false otherwise.
+     * @example `en-US` is valid, `eng-US` is not.
+     */
+    static isValid(subtags) {
+        return this.validateSubtags(subtags, 'valid').isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * well-formed as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags meet the grammar defined in the specification.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a well-formed language tag, false otherwise.
+     * @example `en-US` is valid, `english-US` is not.
+     * @public
+     */
+    static isWellFormed(subtags) {
+        return this.validateSubtags(subtags, 'well-formed').isSuccess();
+    }
+    /**
+     * Chooses an appropriate default tag validator given desired and optional current
+     * {@link Bcp47.TagValidity | validation level}.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns An appropriate {@link Bcp47.TagValidator | tag validator} or `undefined` if no
+     * additional validation is necessary.
+     * @internal
+     */
+    static chooseValidator(wantValidity, haveValidity) {
+        if (haveValidity && compareValidity(haveValidity, wantValidity) >= 0) {
+            return undefined;
+        }
+        if (!this._validators) {
+            this._validators = {
+                unknown: new IsWellFormedValidator(),
+                'well-formed': new IsWellFormedValidator(),
+                valid: new IsValidValidator(),
+                'strictly-valid': new IsStrictlyValidValidator()
+            };
+        }
+        return this._validators[wantValidity];
+    }
+    /**
+     * Validates supplied {@link Bcp47.Subtags | subtags } to a requested
+     * {@link Bcp47.TagValidity | validity level}, if necessary.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to be validated.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns `Success` with the validated {@link Bcp47.Subtags | subtags }, or
+     * `Failure` with details if an error occurs.
+     * @public
+     */
+    static validateSubtags(subtags, wantValidity, haveValidity) {
+        var _a;
+        const validator = this.chooseValidator(wantValidity, haveValidity);
+        // istanbul ignore next - a pain to test
+        return (_a = validator === null || validator === void 0 ? void 0 : validator.validateSubtags(subtags)) !== null && _a !== void 0 ? _a : succeed(true);
+    }
+}
+ValidateTag._validators = undefined;
+//# sourceMappingURL=validateTag.js.map

package/dist/packlets/iana/common/converters.js

@@ -0,0 +1,58 @@
+/*
+ * 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 Validate from './validate';
+import { Converters } from '@fgv/ts-utils';
+/**
+ * Validating converter from string {@link Iana.Model.YearMonthDaySpec}.
+ * @public
+ */
+export const yearMonthDaySpec = Validate.yearMonthDateSpec.converter;
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha2RegionCode}.
+ * @public
+ */
+export const isoAlpha2RegionCode = Validate.isoAlpha2RegionCode.converter;
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha3RegionCode}.
+ * @public
+ */
+export const isoAlpha3RegionCode = Validate.isoAlpha3RegionCode.converter;
+/**
+ * Validating converter from string {@link Iana.Model.UnM49RegionCode}.
+ * @public
+ */
+export const unM49RegionCode = Validate.unM49RegionCode.converter;
+/**
+ * Helper function which creates a converter that returns a validated {@Link Iana.Model.IDatedRegistry | DatedRegistry}
+ * containing entries of supplied template type `T`.
+ * @param entryConverter - A `Converter<T>` to validate each entry
+ * @returns A new validating `Converter` which yields {@Link Iana.Model.IDatedRegistry | DatedRegistry<T>}
+ * @public
+ */
+export function datedRegistry(entryConverter) {
+    return Converters.strictObject({
+        fileDate: yearMonthDaySpec,
+        entries: Converters.arrayOf(entryConverter)
+    });
+}
+//# sourceMappingURL=converters.js.map

package/dist/packlets/iana/common/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