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

package/dist/packlets/bcp47/languageTag.js

@@ -0,0 +1,363 @@
+/*
+ * 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 { captureResult, succeed } from '@fgv/ts-utils';
+import { UndeterminedLanguage, subtagsToString } from './common';
+import { mostNormalized } from './normalization/common';
+import { mostValid } from './validation/common';
+import { LanguageRegistryData } from './languageRegistryData';
+import { LanguageTagParser } from './languageTagParser';
+import { NormalizeTag } from './normalization';
+import { ValidateTag } from './validation';
+/**
+ * Represents a single BCP-47 language tag.
+ * @public
+ */
+export class LanguageTag {
+    /**
+     * Constructs a {@link Bcp47.LanguageTag | LanguageTag }.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } from
+     * which the tag is constructed.
+     * @param validity - Known {@link Bcp47.TagValidity | validation level} of the
+     * supplied subtags.
+     * @param normalization - Known {@link Bcp47.TagNormalization | normalization level}
+     * of the supplied subtags.
+     * @param iana - The {@link Iana.LanguageRegistries} used to validate and normalize
+     * this tag.
+     * @internal
+     */
+    constructor(subtags, validity, normalization, iana) {
+        this.subtags = Object.freeze(Object.assign({}, subtags));
+        this._normalization = normalization;
+        this._validity = validity;
+        this.tag = subtagsToString(subtags);
+        this._iana = iana;
+        this.registry = new LanguageRegistryData(this.subtags, iana);
+        if (validity === 'strictly-valid') {
+            this._isStrictlyValid = true;
+            this._isValid = true;
+        }
+        else if (validity === 'valid') {
+            this._isValid = true;
+        }
+        if (normalization === 'preferred') {
+            this._isPreferred = true;
+            this._isCanonical = true;
+        }
+        else if (normalization === 'canonical') {
+            this._isCanonical = true;
+        }
+    }
+    /**
+     * The effective script of this language tag, if known.
+     * The effective script is the script subtag in the tag itself,
+     * if present, or the `Suppress-Script` defined in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA subtag registry}
+     * for the primary language of this tag.  Can be `undefined`
+     * if neither the tag nor the IANA registry define a script.
+     */
+    get effectiveScript() {
+        var _a;
+        return (_a = this.subtags.script) !== null && _a !== void 0 ? _a : this.getSuppressedScript();
+    }
+    /**
+     * Determines if this tag represents the special `undetermined` language.
+     */
+    get isUndetermined() {
+        var _a;
+        /* c8 ignore next */
+        return ((_a = this.subtags.primaryLanguage) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === UndeterminedLanguage;
+    }
+    /**
+     * Whether this language tag is valid.
+     */
+    get isValid() {
+        if (this._isValid === undefined) {
+            this._isValid = ValidateTag.isValid(this.subtags);
+            if (this._isValid) {
+                this._validity = 'valid';
+            }
+        }
+        return this._isValid === true;
+    }
+    /**
+     * Whether if this language tag is strictly valid.
+     */
+    get isStrictlyValid() {
+        if (this._isStrictlyValid === undefined) {
+            this._isStrictlyValid = ValidateTag.isStrictlyValid(this.subtags);
+            if (this._isStrictlyValid) {
+                this._validity = 'strictly-valid';
+            }
+        }
+        return this._isStrictlyValid === true;
+    }
+    /**
+     * Whether this language tag is in canonical form.
+     */
+    get isCanonical() {
+        if (this._isCanonical === undefined) {
+            this._isCanonical = ValidateTag.isCanonical(this.subtags);
+            if (this._isCanonical) {
+                this._normalization = 'canonical';
+            }
+        }
+        return this._isCanonical === true;
+    }
+    /**
+     * Whether this language tag is in preferred form.
+     */
+    get isPreferred() {
+        if (this._isPreferred === undefined) {
+            this._isPreferred = ValidateTag.isInPreferredForm(this.subtags);
+            if (this._isPreferred) {
+                this._normalization = 'preferred';
+            }
+        }
+        return this._isPreferred === true;
+    }
+    /**
+     * Whether this language tag is a grandfathered tag.
+     */
+    get isGrandfathered() {
+        return this.subtags.grandfathered !== undefined;
+    }
+    /**
+     * Gets a text description of this tag.
+     */
+    get description() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const parts = [];
+        if (!this.subtags.grandfathered) {
+            if (this.registry.primaryLanguage || this.subtags.primaryLanguage) {
+                parts.push(((_b = (_a = this.registry.primaryLanguage) === null || _a === void 0 ? void 0 : _a.description[0]) !== null && _b !== void 0 ? _b : this.subtags.primaryLanguage));
+            }
+            if (this.registry.extlangs) {
+                for (const e of this.registry.extlangs) {
+                    parts.push(`/ ${(_d = (_c = e.registry) === null || _c === void 0 ? void 0 : _c.description[0]) !== null && _d !== void 0 ? _d : e.subtag}`);
+                }
+            }
+            if (this.subtags.script) {
+                parts.push(`in ${(_f = (_e = this.registry.script) === null || _e === void 0 ? void 0 : _e.description[0]) !== null && _f !== void 0 ? _f : this.subtags.script} script`);
+            }
+            if (this.subtags.region) {
+                parts.push(`as spoken in ${(_h = (_g = this.registry.region) === null || _g === void 0 ? void 0 : _g.description[0]) !== null && _h !== void 0 ? _h : this.subtags.region}`);
+            }
+            if (this.registry.variants && this.registry.variants.length > 0) {
+                for (const e of this.registry.variants) {
+                    parts.push(`(${(_k = (_j = e.registry) === null || _j === void 0 ? void 0 : _j.description[0]) !== null && _k !== void 0 ? _k : e.subtag})`);
+                }
+            }
+            if (this.registry.extensions && this.registry.extensions.length > 0) {
+                for (const e of this.registry.extensions) {
+                    parts.push(`(${(_m = (_l = e.registry) === null || _l === void 0 ? void 0 : _l.description[0]) !== null && _m !== void 0 ? _m : `-${e.singleton}`} "${e.value}")`);
+                }
+            }
+            if (this.subtags.privateUse && this.subtags.privateUse.length > 0) {
+                parts.push(`(-x "${this.subtags.privateUse.join('-')}")`);
+            }
+        }
+        else {
+            parts.push(`${this.tag} (grandfathered)`);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Creates a new {@link Bcp47.LanguageTag | language tag} from a supplied `string` tag
+     * using optional configuration, if supplied.
+     * @param tag - The `string` tag from which the {@link Bcp47.LanguageTag | language tag}
+     * is te be constructed.
+     * @param options - (optional) set of {@link Bcp47.ILanguageTagInitOptions | init options}
+     * to guide the validation and normalization of this tag.
+     * @returns `Success` with the new {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     */
+    static createFromTag(tag, options) {
+        options = this._getOptions(options);
+        return LanguageTagParser.parse(tag, options.iana).onSuccess((subtags) => {
+            return this._createTransformed(subtags, 'unknown', 'unknown', options);
+        });
+    }
+    /**
+     * Creates a new {@link Bcp47.LanguageTag | language tag} from a supplied
+     * {@link Bcp47.Subtags | subtags} using optional configuration,
+     * if supplied.
+     * @param tag - The {@link Bcp47.Subtags | subtags} from which the
+     * {@link Bcp47.LanguageTag | language tag} is te be constructed.
+     * @param options - (optional) set of {@link Bcp47.ILanguageTagInitOptions | init options}
+     * to guide the validation and normalization of this tag.
+     * @returns `Success` with the new {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     */
+    static createFromSubtags(subtags, options) {
+        return this._createTransformed(subtags, 'unknown', 'unknown', options);
+    }
+    /**
+     * Creates a new {@link Bcp47.LanguageTag | language tag} from a supplied `string`
+     * tag or {@link Bcp47.Subtags | subtags} using optional configuration,
+     * if supplied.
+     * @param from - The `string` tag or {@link Bcp47.Subtags | subtags} from
+     * which the {@link Bcp47.LanguageTag | language tag} is te be constructed.
+     * @param options - (optional) set of {@link Bcp47.ILanguageTagInitOptions | init options}
+     * to guide the validation and normalization of this tag.
+     * @returns `Success` with the new {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     */
+    static create(from, options) {
+        if (typeof from === 'string') {
+            return this.createFromTag(from, options);
+        }
+        else {
+            return this.createFromSubtags(from, options);
+        }
+    }
+    /**
+     * Constructs a new {@link Bcp47.LanguageTag | language tag} by applying appropriate transformations
+     * to as supplied {@link Bcp47.Subtags | Bcp47.Subtags}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags} which represent the tag.
+     * @param fromValidity - The {@link Bcp47.TagValidity | validation level} of the supplied subtags.
+     * @param fromNormalization - The {@link Bcp47.TagNormalization | normalization level} fo the
+     * supplied subtags.
+     * @param partialOptions - Any {@link Bcp47.ILanguageTagInitOptions | initialization options}.
+     * @returns `Success` with the corresponding {@link Bcp47.LanguageTag | language tag} or `Failure`
+     * with details if an error occurs.
+     * @internal
+     */
+    static _createTransformed(subtags, fromValidity, fromNormalization, partialOptions) {
+        const options = this._getOptions(partialOptions);
+        return ValidateTag.validateSubtags(subtags, options.validity, fromValidity)
+            .onSuccess(() => {
+            return NormalizeTag.normalizeSubtags(subtags, options.normalization, fromNormalization);
+        })
+            .onSuccess((normalized) => {
+            const validity = mostValid(fromValidity, options.validity);
+            const normalization = mostNormalized(fromNormalization, options.normalization);
+            return captureResult(() => new LanguageTag(normalized, validity, normalization, options.iana));
+        });
+    }
+    /**
+     * Gets a fully-specified {@link Bcp47.ILanguageTagInitOptions} from partial or undefined
+     * options, substituting defaults as appropriate.
+     * @param options - The {@link Bcp47.ILanguageTagInitOptions} to be expanded, or `undefined`
+     * for default options.
+     * @returns Fully-specified {@link Bcp47.ILanguageTagInitOptions | init options}.
+     * @internal
+     */
+    static _getOptions(options) {
+        var _a, _b, _c;
+        return {
+            iana: (_a = options === null || options === void 0 ? void 0 : options.iana) !== null && _a !== void 0 ? _a : Iana.DefaultRegistries.languageRegistries,
+            validity: (_b = options === null || options === void 0 ? void 0 : options.validity) !== null && _b !== void 0 ? _b : 'well-formed',
+            normalization: (_c = options === null || options === void 0 ? void 0 : options.normalization) !== null && _c !== void 0 ? _c : 'none'
+        };
+    }
+    /**
+     * Returns the `Suppress-Script` value defined for the primary language of this tag,
+     * regardless of whether a different script is defined in this subtag.
+     * @returns The suppress-script defined for the primary language, or undefined if
+     * the primary language is invalid or has no defined suppressed script.
+     */
+    getSuppressedScript() {
+        if (this._suppressedScript === undefined) {
+            this._suppressedScript = false;
+            if (this.subtags.primaryLanguage) {
+                const language = this._iana.subtags.languages.tryGet(this.subtags.primaryLanguage);
+                if ((language === null || language === void 0 ? void 0 : language.suppressScript) !== undefined) {
+                    this._suppressedScript = language.suppressScript;
+                }
+            }
+        }
+        return this._suppressedScript ? this._suppressedScript : undefined;
+    }
+    /**
+     * Gets a confirmed valid representation of this language tag.
+     * @returns `Success` with a valid representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be validated.
+     */
+    toValid() {
+        if (this.isValid) {
+            return succeed(this);
+        }
+        const options = {
+            iana: this._iana,
+            validity: 'valid',
+            normalization: this._normalization
+        };
+        return LanguageTag._createTransformed(this.subtags, this._validity, this._normalization, options);
+    }
+    /**
+     * Gets a confirmed strictly valid representation of this language tag.
+     * @returns `Success` with a strictly valid representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be strictly validated.
+     */
+    toStrictlyValid() {
+        if (this.isStrictlyValid) {
+            return succeed(this);
+        }
+        const options = {
+            iana: this._iana,
+            validity: 'strictly-valid',
+            normalization: this._normalization
+        };
+        return LanguageTag._createTransformed(this.subtags, this._validity, this._normalization, options);
+    }
+    /**
+     * Gets a confirmed canonical representation of this language tag.
+     * @returns `Success` with a canonical representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be normalized to canonical form.
+     */
+    toCanonical() {
+        if (this.isCanonical) {
+            return succeed(this);
+        }
+        const options = {
+            iana: this._iana,
+            validity: this._validity,
+            normalization: 'canonical'
+        };
+        return LanguageTag._createTransformed(this.subtags, this._validity, this._normalization, options);
+    }
+    /**
+     * Gets a confirmed preferred representation of this language tag.
+     * @returns `Success` with a preferred representation of this {@link Bcp47.LanguageTag | language tag},
+     * or `Failure` with details if the tag cannot be normalized to preferred form.
+     */
+    toPreferred() {
+        if (this.isPreferred) {
+            return succeed(this);
+        }
+        const options = {
+            iana: this._iana,
+            validity: 'valid', // preferred requires validity
+            normalization: 'preferred'
+        };
+        return LanguageTag._createTransformed(this.subtags, this._validity, this._normalization, options);
+    }
+    /**
+     * Gets a string representation of this language tag.
+     * @returns A string representation of this language tag.
+     */
+    toString() {
+        return this.tag;
+    }
+}
+//# sourceMappingURL=languageTag.js.map

package/dist/packlets/bcp47/languageTagParser.js

@@ -0,0 +1,275 @@
+/*
+ * 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 { Validate } from './bcp47Subtags';
+/**
+ * @public
+ */
+export class LanguageTagParser {
+    /* c8 ignore next */
+    constructor() { }
+    /**
+     * Parses a string representation of a BCP-47 ({@link https://www.rfc-editor.org/rfc/rfc5646.html | RFC 5646})
+     * language tag, to produce a {@link Bcp47.Subtags | Subtags} object which
+     * breaks out each of the subtags.
+     * @param tag - The `string` language tag to be parsed.
+     * @param iana - Optional {@link Iana.LanguageRegistries | IANA language registries}
+     * to be used.
+     * @returns `Success` with the resulting {@link Bcp47.Subtags | subtags}
+     * or `Failure` with details if an error occurs.
+     * @public
+     */
+    static parse(tag, iana) {
+        /* c8 ignore next */
+        iana = iana !== null && iana !== void 0 ? iana : Iana.DefaultRegistries.languageRegistries;
+        const status = {
+            tag,
+            iana,
+            subtags: tag.split('-'),
+            parsedSubtags: {}
+        };
+        status.next = status.subtags.shift();
+        return allSucceed([
+            this._parseGrandfatheredTag(status),
+            this._parsePrimaryLanguage(status),
+            this._parseExtlang(status),
+            this._parseScript(status),
+            this._parseRegion(status),
+            this._parseVariants(status),
+            this._parseExtensions(status),
+            this._parsePrivateSubtags(status),
+            this._parseTagEnd(status)
+        ], status).onSuccess(() => {
+            return succeed(status.parsedSubtags);
+        });
+    }
+    /**
+     * Determines if the entire tag matches a registered grandfathered tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with the updated {@link Bcp47.Subtags | subtags}
+     * if a grandfathered tag is found, or `Success` with the supplied subtags
+     * if no matching grandfathered tag is found.
+     * @internal
+     */
+    static _parseGrandfatheredTag(state) {
+        const grandfathered = state.iana.subtags.grandfathered.tryGet(state.tag);
+        if (grandfathered) {
+            state.parsedSubtags.grandfathered = state.tag;
+            // we consumed the whole thing
+            state.subtags.splice(0, state.subtags.length);
+            state.next = undefined;
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Parses the primary language subtag of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the primary language subtag, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parsePrimaryLanguage(state) {
+        // primary language subtag is required unless the entire tag is grandfathered or consists
+        // of only private tags
+        if (state.iana.subtags.languages.isWellFormed(state.next)) {
+            state.parsedSubtags.primaryLanguage = state.next;
+            state.next = state.subtags.shift();
+            return succeed(state.parsedSubtags);
+        }
+        else if (state.parsedSubtags.grandfathered !== undefined) {
+            return succeed(state.parsedSubtags);
+        }
+        else if (Validate.privateUsePrefix.isWellFormed(state.next)) {
+            // just return with no primary language and the private tag
+            // parser will be invoked by the parent flow.
+            return succeed(state.parsedSubtags);
+        }
+        return fail(`${state.tag}: no primary language subtag`);
+    }
+    /**
+     * Parses the extlang subtag(s) of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include extlang subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseExtlang(state) {
+        // optional extlangs subtags
+        while (state.iana.subtags.extlangs.isWellFormed(state.next)) {
+            if (state.parsedSubtags.extlangs === undefined) {
+                state.parsedSubtags.extlangs = [state.next];
+            }
+            else if (state.parsedSubtags.extlangs.length < 3) {
+                state.parsedSubtags.extlangs.push(state.next);
+            }
+            else {
+                return fail(`${state.next}: too many extlang subtags`);
+            }
+            state.next = state.subtags.shift();
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Parses the script subtag of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the script subtag if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseScript(state) {
+        // optional script subtag
+        if (state.iana.subtags.scripts.isWellFormed(state.next)) {
+            state.parsedSubtags.script = state.next;
+            state.next = state.subtags.shift();
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Parses the region subtag of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the region subtag if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseRegion(state) {
+        // optional region subtag
+        if (state.iana.subtags.regions.isWellFormed(state.next)) {
+            state.parsedSubtags.region = state.next;
+            state.next = state.subtags.shift();
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Parses the variant subtag(s) of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the variant subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseVariants(state) {
+        // optional variant subtags
+        while (state.iana.subtags.variants.isWellFormed(state.next)) {
+            if (state.parsedSubtags.variants === undefined) {
+                state.parsedSubtags.variants = [state.next];
+            }
+            else {
+                state.parsedSubtags.variants.push(state.next);
+            }
+            state.next = state.subtags.shift();
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Parses the extension subtag(s) of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the extension subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseExtensions(state) {
+        // optional extension subtags
+        while (state.next !== undefined && Validate.extensionSingleton.isWellFormed(state.next)) {
+            const singleton = state.next;
+            const values = [];
+            state.next = state.subtags.shift();
+            while (Validate.extensionSubtag.isWellFormed(state.next)) {
+                values.push(state.next);
+                state.next = state.subtags.shift();
+            }
+            if (state.next !== undefined &&
+                !Validate.extensionSingleton.isWellFormed(state.next) &&
+                !Validate.privateUsePrefix.isWellFormed(state.next)) {
+                return fail(`${state.next}: malformed extension subtag`);
+            }
+            else if (values.length < 1) {
+                return fail(`${state.tag}: extension '${singleton}' must have at least one subtag.`);
+            }
+            const value = values.join('-');
+            if (state.parsedSubtags.extensions === undefined) {
+                state.parsedSubtags.extensions = [{ singleton, value }];
+            }
+            else {
+                state.parsedSubtags.extensions.push({ singleton, value });
+            }
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Parses the private use subtags of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the private-use subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parsePrivateSubtags(state) {
+        // optional private use subtags
+        if (state.next !== undefined && Validate.privateUsePrefix.isWellFormed(state.next)) {
+            const values = [];
+            state.next = state.subtags.shift();
+            while (state.next &&
+                state.next.length > 1 &&
+                Iana.LanguageSubtags.Validate.extendedLanguageRange.isWellFormed(state.next)) {
+                values.push(state.next);
+                state.next = state.subtags.shift();
+            }
+            if (state.next !== undefined) {
+                return fail(`${state.next}: malformed private-use subtag`);
+            }
+            else if (values.length < 1) {
+                return fail(`${state.tag}: private-use tag must have at least one subtag.`);
+            }
+            state.parsedSubtags.privateUse = values;
+        }
+        return succeed(state.parsedSubtags);
+    }
+    /**
+     * Verifies {@link Bcp47.ParserState | parser state} at the end of a parse operation.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` if the tag was fully consumed, or `Failure` with details
+     * if unexpected subtags remain to be parsed.
+     * @internal
+     */
+    static _parseTagEnd(state) {
+        if (state.next !== undefined) {
+            return fail(`${state.next}: unexpected subtag`);
+        }
+        return succeed(state.parsedSubtags);
+    }
+}
+//# sourceMappingURL=languageTagParser.js.map